High-VelocityAgent IDE
Structured coding runs through multi-agent review. Draft, challenge, vote, and audit before the result lands.
Every model. Every stage. One equal vote each.
The 7 stages below are not separate AI personalities — they are structured review phases that every model you select passes through together. Each model casts a binary yes/no vote at each stage; a no comes with its reasoning. A single no from any model blocks the run from advancing until the council resolves it into a genuine yes. Two models take on per-stage coordination duties (Lead: synthesises the discussion; Writer: authors the output artifact) — but their vote carries exactly the same weight as every other Guardian in the council.
Equal council, rotating duties
Every selected model is an equal-vote Guardian for the whole run. Lead and Writer are duties that move between Guardians as the pipeline advances — never a higher rank.
The code stage — the Writer drafts the implementation while the council critiques.
Guardian. Every selected model. Equal vote, every stage, the whole run.
Lead. A per-stage duty: coordinates the discussion and announces the outcome — votes with equal weight. It moves to a different Guardian every stage.
Writer. A per-stage duty: the only model that writes code or runs commands, at the build stages. It also rotates between Guardians.
Binary vote. Each Guardian votes Yes or No — there is no third option. A No never ends the run: it loops back to deliberation, the council brings counter-arguments, and it resolves into a genuine Yes.
More models, more perspectives
Your plan sets how many equal-vote Guardians sit on the council. Every Guardian still votes with the same weight at every stage — a larger council just means more independent perspectives debating before anything ships.
Solo model — a single Guardian.
A three-model council quorum.
Five models debate every stage.
Up to ten Guardians at the table.
Enterprise plans seat custom council sizes and may bring their own model keys. See pricing for the live plan catalog.
Connector
Interactive requirements Q&A — all models clarify scope together
"What is the exact success criterion for this task?"
Strategist
Planning — the council aligns on approach and trade-offs
"Here are three viable approaches with their trade-offs."
Architect
System design — interfaces, modules, and data contracts
"The interface contract must be established before implementation begins."
Maverick
Code draft — the Writer produces the first implementation
"Draft written. Submitting for council review."
Optimizer
Refine and challenge — the full council critiques the draft
"The draft is correct but this path can be O(n log n) instead of O(n²)."
Guardian
Red-team and security audit — adversarial review by all models
"Input is not sanitized here — this is an injection vector."
Debugger
Final validation — the council verifies correctness end-to-end
"Root cause traced three layers deep. Fix confirmed, regression covered."
The 7-stage council pipeline
One council, seven stages. Every model is an equal-vote Guardian the whole run; the Lead and Writer duties move between them stage by stage.
Actually runs the project; any failure goes back to the council and is worked to a genuine pass before finishing.
- Read
- Docs + Web
- Write / Edit
- Run
- Read
- Docs + Web
- Write / Edit
- Run
Read & research belong to every Guardian. Write & Run belong to the Writer only, and only at Maverick (04) and Optimizer (05).
- LeadA per-stage duty: coordinates the discussion and announces the outcome — votes with equal weight. It moves to a different Guardian each stage.
- WriterA per-stage duty: the only model that writes code or runs commands, at the build stages.
Core Features
The technology behind the desktop workflow
SAMI Context Engine
A multi-layered retrieval pipeline that understands code structure. It intelligently switches between vector retrieval for semantics and keyword search for exact symbol matches.
- Semantic Graph Retrieval
- Token Usage Optimization
- Repo-Aware Indexing
Adversarial Consensus
Every model you select is an equal-weight Guardian across all 7 stages. Voting is binary — yes or no — and a blocking no must carry a written rationale. A no is never dropped or rubber-stamped: the council deliberates, bringing counter-arguments or alternatives, until the objection resolves into a genuine yes. A run never silently hard-stops on an objection.
- Equal-weight binary voting: yes / no
- A no must carry a written reason and is resolved through discussion, never silently dropped.
- Council re-deliberates on every no until it becomes a genuine yes
Execution-Verify Gate
A council that doesn't just agree — it runs the code. Most AI tools vote on plausibility; SAMI's council votes on proven behaviour. It actually runs the project's build, tests, lint, and typecheck and feeds the real result back before any verdict is reached. A passing run is proven, not assumed. A failing run is put in front of the council with the real failure in view — the council either accepts it or blocks on it, which flows into the same never-abort resolution loop as a veto.
- Votes on proven run output, not plausibility
- Failing runs surface the real error to the council
- A failing run is resolved by the council to a genuine yes, never silently stopped
Security-First Pipeline
Industrial-grade security is baked into the development lifecycle. Automated red-teaming and dependency auditing occur before a single line of code is merged.
- Automated Red-Teaming
- Vulnerability Scanning
- Audit-Ready Logs
Multi-Project Context
Manage complex microservices or mono-repos with ease. SAMI maintains independent context pools for each project while allowing cross-repo knowledge sharing.
- Isolation by Design
- Cross-Project Referencing
- Context Hot-Swapping
One shared context, every stage
The context engine grounds the whole run. A shared baseline context flows under every stage, each stage pulls its own slice on top, and any model can look back at what another said earlier in the run.
Hybrid retrieval blends semantic, keyword and code intelligence into one project-context stream the council can draw on.
- Shared baseline context — every stage reads it
- Per-stage context slice — pulled on top into each stage
- Cross-stage recall — look back at earlier council context
The IDE You Already Know
Built on a familiar editor foundation — with all the extensions you love, plus an entire AI team working for you.
Curated access to leading models without requiring individual API keys.
Unified billing across all provider models used within your workspace.
Automatic failover routing to ensure high availability for all agents.
Security-controlled access layers for sensitive enterprise environments.
Familiar Editor Base
Same editor foundation you already know — same shortcuts, same keybindings, no relearning curve
Industry-Standard Code Editor
Familiar coding surface with full IntelliSense support
Live Multi-Agent Chat
Watch agents discuss and debate in real-time
Live Diff View
Real-time streaming of code changes
Semantic Search
Find code by meaning, not just text
External Tool Integration
Connect approved tools and data sources explicitly when a run needs them
Managed Model Access
SAMI uses a curated model catalog. You choose the model that fits your plan and we handle routing, billing, and safety controls behind a single managed runtime.
Curated Model Catalog
Pick from the models SAMI currently offers. No provider setup, no key management, no separate billing.
Centralized Routing
Requests are routed through SAMI's managed provider layer for consistent latency, failover, and billing behavior.
Managed Security
Provider credentials stay inside SAMI infrastructure while your plan controls access to the available models.
How SAMI Compares
Other tools give you one AI assistant. SAMI runs a council of models that debate, vote, and must reach consensus before any result is accepted.
| Feature | SAMI (IDE) | Copilot (VS Code) | Cursor (IDE) | Windsurf (IDE) | v0 (Vercel) | Bolt (Netlify) | Lovable |
|---|---|---|---|---|---|---|---|
| Primary AI Logic | Configurable AI Review | Single Chat Agent | Composer / Single Agent | Cascade Flow | UI Generation | Scaffold Bot | App Logic Gen |
| Cognitive Architecture | Multi-Stage Pipeline | Reactive Chat | Reactive Edits | Sequential Cascade | Component Gen | App Generation | App Generation |
| Validation Strategy | Peer Review & Veto | Manual | Iterative Fixes | Agentic Fixes | Visual Feedback | Terminal Errors | Terminal Errors |
| Multi-Agent Debate | |||||||
| Autonomous Debugging | Deep Audit Pass | Manual | Agentic Assist | Cascade Fix | UI Refiner | Self-Heal (Basic) | One-Click Fix |
| Integrated Browser | Full Subagent | Limited View | Live View | Web-Container | Live Preview | ||
| Data Sovereignty | Managed Model Access | Enterprise Cloud | SaaS Privacy Mode | Codeium Cloud | Vercel Ecosystem | Netlify Cloud | Lovable Cloud |
| Code Ownership | Local Filesystem | Local Filesystem | Local Filesystem | Local Filesystem | Git Sync | Git Sync | Export to GitHub |
| Agent Manager | Multi-Project Control | Global Settings | Single Context | Single Context | Project View | Project View | Project Focus |
Start with a free account.
Start with the desktop workflow. Manage account and billing from the web dashboard.