Plan. Parallelize. Merge. Verify. Ship stronger work.
Meterless Swarms Lite is a local-first multi-agent execution engine. It ships as a Tauri desktop app (Windows .msi / .exe) and as a web build you can host anywhere.
Give it one task. It turns that task into a coordinated system that can plan, distribute work, run specialist agents in parallel, merge outputs, verify quality, and return a stronger final result than any single agent could produce alone.
This is not "chat with AI."
It is:
Design → Distribute → Execute → Synthesize → Verify
Most AI tools are still built around a fragile pattern:
Prompt → Model → Output
That works for small tasks.
It breaks when the work becomes real:
- The task is too large for one pass
- You need many variations, not one shot
- Context decays over long runs
- Quality varies wildly between outputs
- Synthesis becomes manual labor
- One model's blind spots become the final answer
Meterless Swarms Lite changes the unit of work.
Prompt → DAG Plan → Parallel Agents → Merge → Verify → Output
Instead of asking one model to do everything, you get a coordinated system that breaks work apart, runs specialists in parallel, reconciles outputs, and validates what comes back.
Grab the latest installer from the releases page (either the .msi or the NSIS .exe) and install. The app launches on its own and stores everything under %APPDATA%\MeterlessSwarmsLite.
git clone https://github.com/meterless-ai/meterless-swarms-lite.git
cd meterless-swarms-lite
npm install
npm run devTo build the Tauri installers locally:
npm run tauri:buildTo build just the web bundle:
npm run buildThe web bundle in dist/ uses relative asset paths so it deploys to any static host (DreamHost, S3, GitHub Pages, etc.) regardless of subfolder.
Generate 25 homepage hero variations for a local-first AI product.
Group the strongest patterns.
Synthesize one final version.
Explain why it won.
"Generate 100 landing page variations, find the strongest patterns, and combine them into one final version."
A normal tool gives you one output or 50 disconnected drafts.
Swarms Lite does something different.
It can:
- Build a task graph
- Plan distinct angles up front so every variant lands on a genuinely different idea
- Assign each variant a distinct posture role (Researcher, Skeptic, Minimalist, etc.)
- Stagger sampling temperature across variants for categorically different output shapes
- Run them in parallel with adaptive concurrency
- Share findings through a blackboard
- Merge the strongest artifacts under a dedicated synthesis prompt
- Verify completeness before shipping the result
You do not get 100 loose answers.
You get the best final answers the system could synthesize from all 100.
| Capability | What it does | Why it matters |
|---|---|---|
| DAG Planning | Turns prompts into validated task graphs | Complex work gets structure before execution |
| Parallel Variants | Fan out a prompt into up to 300 parallel agents (configurable to 500) | Large tasks cover more angles in less time |
| Adaptive Concurrency | Worker pool scales with variant count, capped by your Settings slider | Small runs stay polite, big runs saturate your provider |
| Variant Angle Planner | One ARCHITECT call invents N distinct angles per fanout, with distinctness validation | Variants land on genuinely different ideas, not 10 paraphrases |
| Role Postures | Each variant runs under a distinct posture role (Researcher, Skeptic, Minimalist, etc.) | The system prompt itself varies, not just the angle |
| Temperature Variance | Three-tier sampling ladder (0.4 / 0.7 / 1.0) across variants | Categorically different outputs at no extra cost |
| Blackboard Coordination | Shares intermediate outputs across agents | Downstream tasks build on upstream findings |
| Merger Auto-Scaling | Fan-in nodes auto-detect and get bigger output budgets (up to 128k) | Synthesizing many variants doesn't get truncated |
| Merger Synthesis Prompt | Dedicated system prompt for fan-in tasks naming the synthesis discipline | Mergers produce coherent results, not concatenations |
| Verification Phase | A verifier checks merged output and can spawn follow-up agents | Output is checked before it ships |
| Markovian Engine | Chunked execution with @@@STATE@@@ carryover between calls |
Long tasks scale without context collapse |
| H-MEM 4.0 | Hierarchical memory across sessions with semantic + entity retrieval | The system learns how you work over time |
| Local-First Persistence | All runs, artifacts, and memory stored in IndexedDB | Your work survives crashes and reopens |
| Live Artifact Refinement | Markdown and HTML artifacts can be surgically edited via diff | Iterate continuously instead of restarting |
| System Telemetry | Per-task Markovian-vs-Standard-CoT chart, live and historical | See exactly what the engine saved you |
| Mixed Model Routing | Per-task model rotation across providers in one DAG | Different DAG steps can use different models |
| Swarm Settings Tab | User-tunable variant max, concurrency, and prompt-enrichment toggles | Tune the engine to your provider tier and use case |
flowchart TD
A[Prompt] --> B[Scout Intent Detection]
B --> C[DAG Plan Built In-App]
C --> D[swarmScheduler: Topological Sort]
D --> E[Parallel Agent Groups]
E --> F[swarmAgentRunner: Per-Task Dispatch]
F --> G[Blackboard State]
G --> H[swarmMerger: Synthesis]
H --> I[swarmVerifier: QA]
I --> J[Final Output + Run Report]
Each stage maps to a real subsystem:
src/services/swarm/swarmScheduler.ts
src/services/swarm/swarmAgentRunner.ts
src/services/swarm/swarmMerger.ts
src/services/swarm/swarmVerifier.ts
src/services/swarm/swarmSpawnDecisionEngine.ts
src/services/swarm/swarmDynamicRoleRegistry.ts
src/services/swarm/swarmPlanMutation.ts
src/services/swarm/swarmRolePrompts.ts
src/services/swarm/swarmRuntimeSettings.ts
Swarms Lite is designed to show the work, not hide it.
Swarms Lite is not a sequential loop pretending to be a swarm.
It builds a dependency graph, topologically sorts work, identifies parallel execution groups, and dispatches variants with per-task model assignment and provider-aware retry. Concurrency is adaptive: the scheduler scales worker count with variant count (roughly one extra worker per ten variants) up to your configured ceiling. A 6-variant brainstorm runs polite at 4 workers; a 300-variant audit can saturate 30+ if you've slid the cap up for a paid provider tier.
The DAG viewer wraps very wide levels into a grid so a 300-variant fanout stays readable instead of becoming a flat single-row strip. A "Reset view" button re-fits the camera after you've panned away.
Swarms Lite is built for visibility.
You can inspect:
- The task DAG (pan, zoom, fit-to-view)
- Agent assignments and per-task model overrides
- Per-task token usage versus the model's max-output ceiling
- Intermediate artifacts
- Live System Telemetry: Markovian-vs-Standard-CoT cost curve as the run unfolds
- Run history with re-open and re-run
- Merge decisions and verification follow-up spawns
- H-MEM audit trail
The experience should feel like a visible workforce, not a hidden black box.
Settings → Swarm gives you direct control over how aggressively the engine fans out and which prompt-enrichment passes run on every variant.
| Setting | Default | Range | What it does |
|---|---|---|---|
| Maximum variants per run | 300 | 1 – 500 | Hard cap on fanout size. Prompts asking for more get silently clamped at plan-build time. |
| Maximum concurrent agents | 6 | 4 – 64 | Upper bound on parallel workers. The scheduler scales up with variant count automatically but never above this. |
| Temperature variance | On | toggle | Stagger sampling temperature across variants (0.4 / 0.7 / 1.0 across three tiers). |
| Role postures | On | toggle | Each variant runs under a distinct posture role so the system prompt itself varies, not just the angle. |
| Merger synthesis prompt | On | toggle | Fan-in tasks get a dedicated synthesis system prompt instead of the leaf template. |
The defaults are conservative on purpose. A first-time user with a free provider tier can ask for 300 variants and not torch their credit balance — workers cap at 6, and the retry layer handles 429s gracefully. Users on paid tiers who want faster wall-clock can slide concurrency up to 30 or 64 and a 300-variant run finishes in a couple of minutes instead of 15.
Swarms Lite runs without a backend.
It uses:
- Tauri shell for the desktop build (Windows .msi / NSIS .exe today; Mac and Linux installers planned)
- IndexedDB for runs, artifacts, telemetry, attachments, chat, scheduled runs, and memory
- LocalStorage for settings, API keys, and mode-routing preferences
- Cloud providers only when you add a key — Google, OpenAI, Anthropic, OpenRouter, OpenCode Go, or any custom OpenAI-compatible endpoint
Your work does not disappear because a tab closed.
| Provider | Wire format | Tool support |
|---|---|---|
| Google (Gemini 3.x, including 3.5 Flash) | :generateContent |
yes |
| OpenAI (GPT-5.5) | /v1/chat/completions |
yes |
| Anthropic (Claude 4.5–4.8) | /v1/messages |
yes |
| OpenRouter | OpenAI-compatible | varies per model |
| OpenCode Go (Qwen, Kimi, DeepSeek, GLM, MiniMax, MiMo) | OpenAI or Anthropic shape | yes |
| Custom OpenAI-compatible (any base URL) | OpenAI-compatible | yes |
Every provider call is wrapped in a retry layer (429 / 5xx / network with exponential backoff + jitter, honors Retry-After).
Every dispatch resolves to one of four app-mode slots, each independently routed to a model:
| App Mode | Used for |
|---|---|
| Code Gen | Default for swarm variant runs |
| Architect | Deeper reasoning, planning, design |
| Research | Multi-file analysis and synthesis |
| Mission | Autonomous swarm / codebase missions |
A quick-pick chip next to the prompt lets you swap the swarm model in one tap. The chip includes two Mixed entries (Premium / Fast) that rotate each DAG task through a different model from the chosen tier, so a single run can use Claude Opus on one task and GPT-5 on the next without opening Settings.
Generate 50 landing pages, loading screens, ad concepts, product names, or UI directions. The merger auto-detects the fan-in and bumps its output budget so synthesis doesn't truncate mid-merge.
Ask the swarm to review a diff or codebase section. Multiple specialists run in parallel (Security, Performance, Architecture roles), the merger reconciles findings, and the verifier flags anything that needs follow-up.
Select a section of a generated Markdown or HTML artifact, describe the change, and the artifact is rewritten in place through your selected cloud model — no re-prompting the whole swarm.
Save a prompt as a scheduled run with a cadence (daily, weekly, monthly). The schedule fires when the app is open or catches up next time you launch.
| Layer | Stack |
|---|---|
| Frontend | React 19, TypeScript, Vite 6 |
| Desktop shell | Tauri 2 (Windows .msi / NSIS .exe; Mac/Linux on the way) |
| Web build | Static dist/ deployable to any host (uses relative asset paths) |
| Persistence | IndexedDB (via idb) + LocalStorage |
| Providers | Google, OpenAI, Anthropic, OpenRouter, OpenCode Go, custom OpenAI-compatible |
| Orchestration | DAG scheduler, agent runner, merger, verifier, dynamic spawn |
| Memory | H-MEM 4.0 with semantic + keyword + entity + recency retrieval |
| Tools | PDF / image / audio / archive / CSV / charts / Pyodide Python |
| Companion | QR-code based mobile viewing modal (MobileRemoteModal) |
The core runtime has no server side. All work routes directly from your machine to whichever AI provider you configured a key for. We never see your prompts, files, or results.
Gaia decides what to do.
Swarms thinks in parallel.
Relay executes in reality.
Use Swarms Lite when:
- The task is complex
- You need many outputs synthesized into one
- You want structured parallel execution
- You care about merge and verification
- You want glass-box multi-agent work
No. It's a full orchestration engine with DAG planning, scheduling, blackboard coordination, merger auto-scaling, verification, hierarchical memory, and persistent run state.
No. The desktop app runs entirely client-side. Cloud models still require network calls when you choose them, but those go directly from your machine to the provider you configured.
Not today. The model registry has a slot for WebLLM local inference but it's gated off at dispatch in this build. Adding a working local-model path is on the roadmap.
The Markovian engine compresses state across chunks using @@@STATE@@@ carryover markers instead of resending the full history every call. You can inspect the per-step cost curve in the agent inspector's Telemetry tab.
Run state is persisted to IndexedDB on every event, so a cancelled or crashed run can be reopened and inspected later. The DAG, per-task statuses, and partial artifacts all survive.
Yes. Open the agent inspector on any task and pick a different model from the dropdown — it sets a per-task model_override that only affects that task's next dispatch.
The engine accepts up to 500 variants per run; default cap is 300. The constraint that matters in practice is your AI provider's rate limit, not the app. A 300-variant run on a free Gemini tier (15 RPM) takes 15-20 minutes regardless of what the app does. On a paid tier (1000+ RPM) the same run finishes in a couple of minutes. The retry layer handles 429s with exponential backoff so nothing fails outright; large runs just take longer on slow tiers.
Settings → Swarm → Maximum concurrent agents. The default of 6 is conservative — it keeps free tiers happy and prevents accidental large fanouts from burning paid credit fast. If you're on a generous paid plan, slide it up to 30 or higher. The scheduler will only use as many workers as it can fill from your variant queue, so raising the cap on a 4-variant run still uses 4 workers.
Yes. Settings → Swarm has individual toggles for temperature variance, role postures, and the merger synthesis prompt. All on by default. Useful when you want a clean A/B test of whether a specific pass helps for your prompts, or when a provider's prompt cache is mis-keyed by the posture variation.
AI is no longer limited only by model quality.
It is limited by:
- How work is structured
- How context is preserved
- How outputs are synthesized
- How quality is verified
Meterless Swarms Lite addresses all four.
It turns one prompt into a coordinated system of agents that can plan, execute, merge, verify, remember, and recover.
See LICENSE.md.