| --- |
| license: apache-2.0 |
| language: |
| - en |
| base_model: Qwen/Qwen3.6-27B |
| base_model_relation: adapter |
| library_name: peft |
| pipeline_tag: image-text-to-text |
| tags: |
| - code |
| - code-generation |
| - coding-agent |
| - agent |
| - agentic |
| - software-engineering |
| - swe-bench |
| - lora |
| - peft |
| - qwen |
| - qwen3 |
| - multimodal |
| - vision |
| - image-to-code |
| - image-text-to-text |
| - execution-verified |
| - best-of-n |
| - self-hostable |
| - open-source |
| - australia |
| --- |
| |
| # SwarmDo-A1 (release candidate) |
|
|
| **SwarmDo-A1 is an open, self-hostable, execution-verified, multimodal coding agent — a LoRA adapter on `Qwen/Qwen3.6-27B` that fixes real software bugs and writes code from images, and verifies its own patches by running the project's tests.** Built in Australia; measured, not marketing — the negatives are published too. |
|
|
| > Public model hub & full results: **https://github.com/SwarmDo/models** |
|
|
| **Keywords:** open-source coding agent · agentic software engineering · SWE-bench-style patch generation · execution-verified best-of-N selection · image-to-code / visual coding · multimodal vision · Qwen3.6-27B LoRA / PEFT adapter · self-hostable on vLLM · Apache-2.0. |
|
|
| SwarmDo-A1 is a coding *system*, not just a checkpoint: a strong re-based open base + a hardened agentic |
| harness that **verifies patches by running the project's tests**, plus a differentiated **exec-grounded |
| visual-coding** capability (turning a screenshot or mockup into working code and checking it by rendering |
| and comparing). This repository holds the fine-tuned **LoRA adapter** (the "A1" delta); the base weights |
| are the open `Qwen/Qwen3.6-27B`. The adapter reaches the architecture's **gated-DeltaNet sequence-mixing |
| layers** (`in_proj_*`, `out_proj`), not just the standard attention projections. |
|
|
| ## What's decision-grade (paired McNemar, held-out, execution-verified) |
|
|
| | Result | Number | Significance | |
| |---|---|---| |
| | Re-basing to Qwen3.6-27B vs the prior 9B base | ≈ **+25 pp** | p = 0.013 (0.004 stricter) | |
| | Base **+ execution-verified selection** vs base alone | **36 vs 24** solved (+50%) | p = 0.0005 | |
| | Visual coding — does the image drive the output? | image-on 15 vs image-off 0 | p = 6e-05 | |
|
|
| These are relative, held-out, execution-verified comparisons on our own task sets — **not** an absolute |
| public-leaderboard pass rate. We deliberately do not post a single "SWE-bench Verified score" we cannot |
| stand behind under paired testing. |
|
|
| ## Honest limitations (published, not buried) |
|
|
| - **This adapter, as a single model, is ~neutral vs the base.** Single-model fine-tuning trades a small |
| quality gain against a robustness cost (a "churn wall"). **A1's value is the *system*** — the base |
| plus execution-grounded best-of-N selection, where the win above (p = 0.0005) lives. |
| - Specialized for Python-centric agentic SWE. Like all coding agents it can produce plausible-but-wrong |
| patches — **always run the project's tests against its output.** Not a general chat assistant. |
|
|
| ## Usage |
|
|
| Serve the base with the adapter loaded (vLLM ≥ 0.19 — the base's `Qwen3_5` architecture supports |
| adapters on its tower modules): |
|
|
| ```bash |
| vllm serve Qwen/Qwen3.6-27B \ |
| --enable-lora --lora-modules swarmdo-a1=SwarmDo/SwarmDo-A1 --max-lora-rank 32 \ |
| --tool-call-parser qwen3_xml --reasoning-parser qwen3 --enforce-eager |
| ``` |
|
|
| Then request `"model": "swarmdo-a1"` on the OpenAI-compatible endpoint (or `"Qwen/Qwen3.6-27B"` for the |
| raw base). Or load with PEFT: |
|
|
| ```python |
| from transformers import AutoModelForImageTextToText, AutoProcessor |
| from peft import PeftModel |
| base = AutoModelForImageTextToText.from_pretrained("Qwen/Qwen3.6-27B", torch_dtype="bfloat16", device_map="auto", trust_remote_code=True) |
| model = PeftModel.from_pretrained(base, "SwarmDo/SwarmDo-A1") |
| processor = AutoProcessor.from_pretrained("Qwen/Qwen3.6-27B", trust_remote_code=True) |
| ``` |
|
|
| **Serving notes:** use `--tool-call-parser qwen3_xml` (not `hermes` — it silently drops tool calls); |
| serve in eager mode if you hit hybrid-attention graph-capture issues; the linear-attention base keeps a |
| fixed-size recurrent state, so long contexts cost prefill tokens, not growing KV cache. |
|
|
| ## License |
|
|
| Apache-2.0, consistent with the base model family. |
|
|
| ## Citation |
|
|
| ```bibtex |
| @software{swarmdo_a1_2026, |
| title = {SwarmDo-A1: An open, execution-verified multimodal coding system}, |
| author = {SwarmDo}, |
| year = {2026}, |
| url = {https://github.com/SwarmDo/models} |
| } |
| ``` |
|
|
|
|
| ## Use cases |
|
|
| - **Automated bug fixing** in Python repositories — generate a patch, then verify it against the project's tests. |
| - **Agentic software engineering** — a coding agent that edits files, runs commands, and self-checks patches. |
| - **Image-to-code / visual coding** — turn a chart, plot, or UI screenshot into the code that reproduces it (render-and-compare verified). |
| - **Self-hosted / private coding assistant** — runs entirely on your own hardware (vLLM, or GGUF via Ollama / LM Studio); no data leaves your machine. |
| - **Best-of-N patch generation** — sample multiple candidate fixes and select the one that passes execution. |
|
|
| ## Run it locally (GGUF — Ollama / LM Studio / llama.cpp) |
|
|
| For a one-command local run, use the GGUF build — **no account needed**: |
|
|
| ```bash |
| ollama run hf.co/SwarmDo/SwarmDo-A1-GGUF:Q4_K_M |
| ``` |
|
|
| GGUF repo: **[SwarmDo/SwarmDo-A1-GGUF](https://huggingface.co/SwarmDo/SwarmDo-A1-GGUF)** (Q4_K_M ~16.5 GB, Q8_0 ~28.6 GB; LM Studio auto-indexes it). The GGUF is text-only; for the full multimodal + execution-verified system, self-host with vLLM as shown above. |
| |
| ## FAQ |
| |
| **Is SwarmDo-A1 open source?** Yes — Apache-2.0, commercial use permitted. Weights, recipe, and full (including negative) results are public. |
| |
| **Can I run it on my own hardware?** Yes. Self-host with vLLM (adapter on Qwen3.6-27B), or run the quantized **GGUF** locally with Ollama / LM Studio / llama.cpp. Q4_K_M fits a single 24 GB GPU or a 32 GB Mac. |
| |
| **What is it based on?** A LoRA/PEFT adapter on **Qwen/Qwen3.6-27B** — a linear-attention hybrid (gated-DeltaNet) base with a vision tower. Apache-2.0. |
| |
| **Does it really do image-to-code?** Yes — it writes code from images (charts/plots/UI) and we verify it by *rendering the output and comparing to the target image* (an objective, reward-hackable-resistant signal), not by eyeballing. |
| |
| **How is it different from other open coding models?** SwarmDo-A1 is a *system*, not just a checkpoint: a strong open base **plus** an execution-verified best-of-N harness that runs the project's tests, **plus** an exec-grounded visual-coding capability. We report paired, held-out, execution-verified deltas — and publish the limitations. |
| |
| **Is it good at SWE-bench?** We report *relative, paired, held-out, execution-verified* wins (e.g. base + execution-verified selection solves 36 vs 24, p = 0.0005), not a single absolute leaderboard number we can't stand behind under paired testing. |
| |
| **What languages?** Python-centric agentic software engineering. It is a coding agent, not a general chat assistant. |
| |
| **Where are the full results?** Public hub: https://github.com/SwarmDo/models |
| |
| --- |
| |
| *Topics: open source coding model · local LLM for coding · self-hosted AI coding assistant · agentic SWE-bench model · image to code / chart to code / screenshot to code · execution-verified code generation · Qwen3.6-27B LoRA · Ollama coding model · run a coding LLM locally · Apache-2.0 code model.* |
| |
| |
