README.md

---
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.*