Loading Accelerated Logic…
GA Release

The Multi-Agent WebGPU Engine & Interactions API are now generally available.

Part 6: Multi-Agent Teams, Presets & Infinity Mode

Stop asking one model to do everything — orchestrate specialist AI teams with self-correcting Infinity loops.

Category: Getting Started • Read Time: 29 min read • Updated: 2026-11-10

1. Why Single Models Fail at Complex Builds

Ask a single model: "Build a full dashboard with auth, charts, and dark mode."

It will attempt planning, design, coding, reviewing, and formatting all in one single pass. Midway through, it forgets its own architectural decisions, invents non-existent APIs, and outputs code with syntax bugs it fails to check.

This is the self-awareness limitation: one LLM stream cannot reliably evaluate its own output while generating it. Multi-Agent architecture solves this by dividing complex tasks among specialized AI roles that verify each other's work:

🧠 Architect

Sketches architectural blueprints and decomposes prompts into execution tasks.

💻 Developer(s)

Writes code, creates surgical diffs, and executes Python verification tools.

🔍 Auditor / Reviewer

Audits security, missing imports, edge cases, and runtime flaws.

✨ Finalizer

Merges outputs into a polished answer and generates interactive visual previews.

2. The Mode Selector — Single vs Multi vs Auto & Infinity

In the composer header, select your execution mode:

Single

Direct single-model pass. Fastest responses; ideal for quick Q&A, explanations, and lightweight code edits.

Multi

Full specialist team execution. Uses higher token volume but produces vastly superior results for full app builds and deep refactoring.

Auto Router

Dynamically evaluates your prompt. Simple questions route to Single; complex feature builds automatically switch to Multi-Agent.

∞ Infinity Mode

Enables self-correcting critic feedback loops. If Auditor finds bugs, the system automatically loops back to Coder (up to 3–5 attempts).

3. Opening the Agent Box — Your Control Room

Click the Agent Box (Layers icon) in the composer header to inspect and customize your team:

Agent Pipeline Flow Visualization:

Shows live connected nodes: Orchestrator → Coder → Auditor → Checker → Finalizer. Nodes pulse actively as each specialist processes.

Agent Controls:
  • Enabled Toggle: Turn optional specialist agents on or off.
  • Fixed Agents: Core pipeline agents (Orchestrator, Auditor, Checker, Finalizer) feature a lock icon and cannot be removed.
  • Parallel Instances (Count 1–5): Set Coder count to 2 or 3 to generate parallel alternative solutions that Finalizer merges.
  • Drag-to-Reorder: Reorder specialists to adjust execution pipeline sequence.

4. Presets — 7 Built-in Specialist Architectures

💻 Software Engineering

Architect, Lead Dev, Security Auditor, Prompt Checker, Finalizer. Optimized for web apps and surgical code diffs.

🎨 Creative & Content

Director, Writer, Editor, Checker, Finalizer. Includes vision and optional image generation hooks.

📊 Data & Analysis

Data Scientist, Analyst, Fact Checker, Finalizer. Leverages Python tools for math verification.

🎓 Education & Research

Curriculum Planner, Tutor, Peer Reviewer, Quiz Architect, Finalizer. Builds comprehensive study guides.

5. Creating & Saving Custom Teams (with AI Edit)

Build custom agent teams by clicking Add Agent. Specify custom system prompts (e.g., "Tailwind Specialist — refine classes to meet WCAG AA contrast").

Click Save Preset to persist your configuration to local storage. In Settings → Multi-Agent Systems, click AI Edit Preset and type prompt instructions like "Add a performance auditor that checks bundle size" to auto-refine team structures using AI.

6. Model Overrides per Specialist Agent

Optimize cost and performance by assigning distinct models to individual agents:

Architect & Checker: Assign fast/inexpensive models (e.g. Gemini 3.5 Flash-Lite).

Lead Developer: Assign high-intelligence reasoning models (e.g. Gemini 3.7 Flash or Claude Sonnet).

Result: Achieve 90%+ of top-tier intelligence output while cutting token costs by up to 70%.

7. Critic Strictness & Infinity Settings

Critic Strictness Slider (1–10): Controls how aggressively the Auditor flags potential errors. Set to 3–4 for fast prototyping; 8–9 for production-grade code reviews.

Infinity Max Attempts: Defines maximum automatic retry loops (default: 3) before forcing final output.

8. Auto Router Intelligence

When Auto Router is enabled, Accelerated Logic AI sends a fast pre-flight query to evaluate your prompt. It automatically enables relevant specialists and disables unneeded roles (e.g., disabling Coder when writing a blog post) to conserve tokens.

9. Multi-Agent Troubleshooting & Edge Cases

Q:
Infinity loops maximum 3 times without resolution

Lower Critic Strictness slider or assign a higher-tier model to the Lead Developer agent.

Q:
Finalizer outputs blank response

Reload the default Software preset in Agent Box to restore standard formatting directives.

10. Reading the Pipeline While It Runs — What Each Node Tells You

A multi-agent run is observable while it happens. Use the activity drawer and the Agent Box node states to know what is normal and what means "stop now":

Stage Healthy signal Stop-and-intervene signal
Orchestrator (Architect)A concrete task decomposition mentioning your actual stack and constraintsGeneric plan that ignores your pinned files — it may not see them; check context before blaming the agents
Developer(s)Incremental code chunks arriving steadily; 2 parallel coders each produce a distinct approachEndless repetition of the same boilerplate or a third retry of identical code — stop and tighten the prompt
AuditorSpecific findings with line references (missing import, unsafe cast, unhandled promise)Every finding is stylistic nitpicking — lower critic strictness (Section 7) or accept and move on
CheckerA pass/fail verdict with reasons; in Infinity loops, concrete fix directives for the CoderScore oscillates across attempts (7→4→8→5) — the model is unstable; split the task or raise the model tier
FinalizerA merged, deduplicated answer with working code and (for UI) a canvas previewBlank or truncated output — reload the default preset (Section 9) rather than re-running blindly

11. Token Economics — When Multi-Agent Actually Pays Off

Every extra specialist is another full model call on your context. A rough way to budget:

Cost model: total tokens ≈ (system prompt + pinned context) × number of agents + each agent's generated output. Pinned context is the multiplier nobody sees — a 6k-token pinned file is 6k tokens billed for every specialist in the pipeline, not once.

  • Single model wins: short Q&A, explanations, one-file edits, anything where the answer fits comfortably in one pass
  • Multi wins: greenfield app builds, multi-file refactors, "find and fix the bug" across a codebase slice, high-stakes text needing independent review
  • Parallel coders only when approaches diverge: 2–3 parallel Coder instances pay off for design exploration; for a bug with one correct fix they just triple the bill — use 1
  • Cheap orchestration, expensive execution: assign Flash-class models to Architect/Checker and a strong model to the Developer — this is the single highest-leverage override (Section 6)
  • Infinity Mode is a multiplier on a multiplier: every attempt re-runs the Coder→Auditor loop; reserve it for production-critical output and watch the attempt counter
Sanity check before a big run: if the Context % badge already reads >70% before you hit send, adding a five-agent pipeline will blow the window on the first specialist. Trim context or start a fresh chat first.

12. A Second Worked Example: The Research Brief (Not Code)

Multi-agent is not only for apps. A research-style team produces sourced-feeling briefs with a built-in review pass — here is the pattern:

  1. Mode: Multi (or Auto Router) with a research-oriented preset — Education & Research works, or clone it into a custom Research Analyst team (Part 12 covers authoring custom skills).
  2. Prompt shape: "Compare WebGPU and WASM for in-browser LLM inference in 2026. Deliver: 5 key findings with trade-offs, a comparison table, and 3 open questions. Use the web-search tool for anything after 2025. Flag anything you could not verify." — explicit scope, explicit deliverable, explicit uncertainty policy.
  3. Why the agents help: the Planner decomposes the question, the Analyst drafts, the Reviewer cross-checks claims against tool output, and the Finalizer merges into one brief. Single-model runs on the same prompt are noticeably more prone to confident-sounding unsupported claims.
  4. Verify externally anyway: tool calls return web content, not truth. Cross-check any number you plan to publish — the pipeline reduces but does not eliminate hallucination (Part 7 covers trace inspection for exactly this).

13. When Auto Router Picks Wrong — and How to Take Back Control

Auto Router is a heuristic pre-flight judge, not an oracle. It sometimes sends a meaty question down the single-model path or escalates trivia into a five-agent run. Spot it and override:

Signs it under-routed (should have been Multi)
  • Answer is plausible but thin, no verification pass happened
  • Pinned files were ignored — you asked for "the bug in this file" and got general advice
  • Fix: select Multi explicitly in the mode selector and re-send the same prompt
Signs it over-routed (should have been Single)
  • Five agents spin up to answer "what does this error code mean?"
  • Token bill (Context %) jumps disproportionately to a trivial ask
  • Fix: select Single, ask the small question, switch back to Auto/Multi for the real task

A reliable habit: leave Auto on for mixed workloads, but pin Multi explicitly when you know the task is a build, and pin Single when you know it is a lookup. The mode is one click away in the composer header at any time.