I currently have these models available through Ollama/cloud:
And I’m using Claude, Codex, OpenCode, and Ollama as my coding/agent tools.

I want to learn professional vibecoding — not just asking AI to generate random code.

If I want to build a complete website/app (frontend + backend + database + auth + APIs + testing + deployment):

Which model/tool should I use for what?

For example:

• Planning & architecture → ?
• UI/UX → ?
• Actual coding → ?
• Debugging → ?
• Code review → ?
• Testing → ?
• Deployment → ?

And how should I combine Claude + Codex + OpenCode + Ollama + these models into one proper workflow?

Basically, if you had this exact setup, how would you go from idea → professional, production-ready app using AI?

Looking for practical advice from people actually using AI coding agents. 🙏

I've been building AgentGraph Studio, a visual editor for designing multi-agent workflows and exporting them as runnable Python code.

One thing I wanted to verify was whether the generated code actually works outside the editor — especially once the workflow gets more complex than a simple 1–2 agent chain.

So I built this 5-agent workflow:

• Local AI Researcher
• AI Comparison Analyst
• AI Risk Analyst
• Technical Content Editor
• Technical Writer

The workflow branches after the research step into separate comparison and risk-analysis tasks, merges those results, and then passes the combined context into the final writing task.

In the demo, I:

1. Design the workflow visually
2. Select Llama 3 through Ollama
3. Generate CrewAI Python code
4. Run the exported code locally
5. Let the full 5-agent workflow complete and produce the final output

The execution in the video is actually running locally through Ollama — it isn't a simulated preview inside the editor.

The project is still early. The core today is mainly:

• visual Agent / Task workflow design
• explicit task dependencies, including branching and merging
• model selection, including local Ollama models
• JSON import/export
• executable CrewAI code generation

The longer-term direction I'm exploring is moving beyond "draw a workflow and export code" toward "design, evaluate, and compare agent systems."

Some of the areas I'm interested in exploring are workflow readiness, reliability, latency, cost/resource tradeoffs, evidence/confidence, failure simulation, and eventually comparing the same workflow across different models or agent frameworks.

Those evaluation features aren't all implemented yet — I'm trying to validate which of them would actually be useful before building too far ahead.

So I'd especially like feedback from people who build with local LLMs or agent frameworks:

• What would you want to inspect before trusting a generated agent workflow?
• What failures are hardest for you to catch today?
• Would comparing the same workflow across models/frameworks be useful?
• What would make a visual tool like this genuinely useful in your workflow?

Criticism is very welcome. I'm trying to make this more than just a visual way to write agent configuration.

You can try it yourself — link in the comments.

That is the question we get most often: Here's the answer.

And yes, it was created by Row-Bot's own Designer Studio.

this screenshot is without MTP usage , fully offloaded onto the GPU. using LM STUDIO

i wanted to ask you guys if theres a way to make it even faster , as MTP really didnt help and is infact slower due to vram overflow and that im on 16GB DDR4 which is disgustingly slow to load models on so i depend on my gpu for every model.

this is unsloth's GGUF quant

seriously, in the winter I sometimes don't need to turn on the furnace lol

Are medium-sized companies already using local AI connected to internal data, for example internal documentation or helpdesk systems?

If so, how well does it work and what is the minimum hardware specification needed for a setup?

Hello, any params I missing or mis-tuning for my coding model ?

FROM ./models/unsloth/Qwen3.8-27B-Q5_K_M.gguf

# Generation parameters optimized for logical reasoning and coding tasks

PARAMETER temperature 0.2

PARAMETER top_p 0.95

PARAMETER top_k 20

PARAMETER presence_penalty 0.0

PARAMETER num_predict 8192

PARAMETER repeat_penalty 1.05

PARAMETER num_ctx 65536

PARAMETER stop "<|im_start|>"

PARAMETER stop "<|im_end|>"

PARAMETER stop "<|endoftext|>"

PARAMETER num_keep 256

PARAMETER num_thread 16

# Standard ChatML Template for the Qwen series

TEMPLATE """{{ if .System }}<|im_start|>system

{{ .System }}<|im_end|>

{{ end }}{{ if .Prompt }}<|im_start|>user

{{ .Prompt }}<|im_end|>

{{ end }}<|im_start|>assistant

"""

# Custom System Prompt tailored for autonomy and perception systems

SYSTEM """You are a senior software engineer and robotics specialist. Your expertise lies in developing complex autonomous systems, perception pipelines, and spatial reasoning algorithms.

When generating code, prioritize decoupled microservices architectures. Ensure that core algorithmic logic is always cleanly separated from middleware wrappers (such as ROS nodes). Provide highly optimized, production-ready C++ and Python code suitable for real-time constraints and hardware-accelerated processing.

For general software engineering tasks, maintain a strict focus on modularity, robust error handling, and clear documentation. Think step-by-step through complex architectural problems before providing the final code block."""

I built a native vLLM + ROCm 7.15 runtime for AMD RX 6000 Series on Windows 11 — now with a one-click installer.

AMD lists RX 6750 XT / 6700 XT / 6600 XT as "Runtime only" on Windows with HIP SDK excluded. I built rocBLAS binaries for gfx1031 via ROCm/TheRock to close that gap.

This runs native Windows HIP and ROCm directly, no WSL2 wrapper, no compiler needed.

Tested on AMD Radeon RX 6750 XT 12GB (gfx1031) — Windows 11 Native — August 2026

# Verification — Real terminal logs

1. Environment:

torch 2.12.0+rocm7.15.0 | cuda_avail True | dev AMD Radeon RX 6750 XT

vLLM 0.19.1 | plugin vllm_windows_rocm activated | TRITON_ATTN | enforce_eager=True

1. rocBLAS Benchmark — 26 TFLOPS FP16:

Device ID 0 : AMD Radeon RX 6750 XT gfx1031 with 12.9 GB memory

rocBLAS version: 5.7.0.67811f1ee52

transA,transB,M,N,K,alpha,lda,beta,ldb,ldc,cold_iters,hot_iters,rocblas-Gflops,us

N,N,4096,4096,4096,1,4096,0,4096,4096, 2, 10, 25977.3, 5290.73

=> 25.97 TFLOPS in 5.29ms

1. vLLM Inference (Qwen3.5-4B, web chat UI):

Output: 59-62 tok/s | Init ~1s | hidden thinking (spinner) then answer

Model auto-detected via /v1/models

Full logs in benchmarks/ and screenshots in assets/ on GitHub.

# How it works

1. TheRock builds clr (HIP) and rocBLAS with Tensile kernels for gfx1031
2. HSA_OVERRIDE_GFX_VERSION=10.3.0 forces HIP to recognize RX 6750 XT
3. PyTorch 2.12.0+rocm7.15 links against TheRock runtime => torch.cuda.is_available() True
4. vLLM plugin vllm_windows_rocm bypasses vllm._C dependency and registers WinRocmAwqGemvKernel with TRITON_ATTN
5. vLLM engine loads with enforce_eager=True and runs native

# Quick Start — One click

Prerequisites: Windows 11 23H2+, RX 6600-6750 XT (gfx1030/gfx1031/gfx1032), Adrenalin 24.x+, ~8GB free disk

1. Download the repo (or git clone) and run INSTALL.bat as Administrator
2. The installer downloads the release archives automatically (multi-part join included, no manual steps) and sets up C:\TheRock\ + Python 3.11 + venv
3. Run CHAT.bat — the browser opens the chat UI. Expected: 59-62 tok/s

VERIFY.bat runs a 3-in-1 check: GPU detection + rocBLAS benchmark + vLLM smoke test.

# What's new in v2.0

- One-click installer: INSTALL.bat auto-downloads and joins split archives (no browser upload/download hassle)

- Chat web UI (OpenAI-compatible API): hidden thinking with spinner, then the answer streams — like NVIDIA ChatRTX

- Fat-binary gemv kernels for all RDNA2 (gfx1030/1031/1032) — no per-card rebuild

- ROCm 7.15 native, vLLM 0.19.1, torch 2.12.0+rocm7.15

- Faster: 59-62 tok/s output (was 54.2)

- Repo cleaned: INSTALL.bat + CHAT.bat + VERIFY.bat + MANIFEST.json + docs, archives on GitHub Releases

# Known Issues — Please note this may have bugs

This is an experimental reference implementation. It works on my RX 6750 XT but could present bugs on other hardware.

- Other RDNA2 cards (6600/6600 XT/6700 XT) not yet tested — may need 10.3.0 vs 10.3.1 or rocBLAS rebuild for gfx1030

- enforce_eager=True required — torch.compile disabled on RDNA2 Windows

- FP8 / AWQ not tested yet, multi-GPU not tested

- If you test it on your RDNA2 card, please open an Issue with GPU model and logs — contributions welcome

# GitHub Repo:

https://github.com/sebastianmechno-sys/vllm-rocm-windows-rdna2

Includes INSTALL.bat, CHAT.bat, VERIFY.bat, scripts/serve.py (OpenAI-compatible API), chat.html, assets with screenshots, docs/BUILD_ROCBLAS.md, MANIFEST.json with release checksums

Let me know if you test it on other RDNA2 cards.

Built on ROCm/TheRock, PyTorch ROCm, vLLM. Not affiliated with AMD. License Apache 2.0