Plans that get
argued, not generated.

What SwarmStack is

SwarmStack is where a whole team plans with AI in real time. Several people — your coworkers by a free join code, and vetted experts you hire — work one shared, server-hosted Session at once, alongside a swarm of AI specialist personas, and argue one deliverable into shape by contention. Not one AI answering alone, and not one person driving a tool.

SwarmStack is the platform; Products are the desks on it. Each Product runs a Session where the room contends, then synthesizes a versioned deliverable. Crucially, the Session surfaces the contention — the points the participants disagreed on and where they landed — so you read a decision and the dissent that shaped it, the way you would after a good design review. The result was argued, not just generated.

Everything is versioned, tenant-isolated, and durable. The platform is one glossary and one architecture; the Products differ only in what they produce and how they read.

Three Products, one engagement shape

A Product either shares SwarmPlan's engagement shape (a Session with a different deliverable) or brings a genuinely different one. All three live today, and all three plug into the same tenancy, marketplace, and design system.

SwarmPlan turns a brief into a versioned software plan. SwarmRFP builds a buyer-side RFP with a weighted scoring rubric. SwarmSurvey runs a conversational survey — one link, an adaptive conversation per respondent, synthesized into a Readout — and is the first Product with a shape of its own.

Anatomy of a Session

A Session moves through the same arc whichever Product it belongs to: Intake establishes the Brief and the room, Rounds of contention iterate the deliverable, Synthesis merges each Round, and the Approval Gate signs it off. Then you turn the plan into work.

The Orchestrator is not a participant in the chat — it is the server's state machine, invoking the model as a set of one-shot gates (Intake, the Persona Task, the Task Interview turn, Synthesis, Review). Each gate runs as a durable Scheduled Action, so a Session survives a restart mid-Round. Watch a real one end-to-end in the self-guided demo.

Core concepts

SwarmStack uses precise words for precise things. These are the ones you meet first; the full vocabulary — every term, with what to avoid calling it — lives on the Glossary.

Who is in the room

A Persona is a seat; a Participant is who holds it. Seats can be filled by a model or by a human, and both work the deliverable in the same Session. When AI hits its limit, you hire a real expert into the exact same room from the Marketplace.

And more than one human can be in a Session at once, in real time. Because a Session lives on the server rather than on any one person's machine, several people plan the same thing together: the Creator, collaborators invited by a free join code, and hired experts. During Intake, a brief-sync step mirrors the brief questions to every collaborator, waits for their answers, synthesizes one Brief, and raises any conflict to the Creator before it locks. There is one shared plan under optimistic concurrency, so the room never forks into copies that later have to be merged — the Team tier exists for exactly this: the whole room in one Session.

Bring your own context

A Session does not have to start from a blank Brief. You can seed it with material you already have, and you can let the swarm read a real codebase.

• Baseline.One uploaded document becomes the SwarmPlan's first version, so the swarm iterates your existing draft instead of planning from scratch.
• References. Read-only material the gates consult but never rewrite — as many as you need.
• Source Lookup. An AI gate reaches into a connected repo, Confluence space, or Jira project during its run to pull context on demand. Nothing pulled is persisted, and raw source is never rendered to any human.
• Clone Targets. The specific repositories (each at an optional ref) a Session reads from a connected GitHub App install, read with short-lived, read-only, repo-scoped tokens minted on demand.
• BYOK.Route a Session through your own Anthropic key and it is off SwarmStack's bill — required whenever you attach a GitHub source.

The design is deliberate: SwarmStack never becomes a mirror of, or a leak path for, your source. Read the full posture on Trust and Security.

Outputs & integrations

A Session produces three versioned artifacts — the SwarmPlan, the Glossary, and a set of Decision Records — and everything downstream derives from them.

From plan to shippable work

A converged SwarmPlan can be transformed into a PRD, which is sliced into a Work Breakdown: Epic → Story → Work Item. A Work Item is a tracer-bullet slice with acceptance criteria and blocked-by edges — the unit that maps to a GitHub Issue or a Jira sub-task.

Publishing

A Publication pushes the artifacts and/or the Work Breakdown to one connected destination through a Connector. Every pushed node is recorded as an External Object with a content fingerprint, so re-publishing is idempotent — it re-syncs the same issues instead of duplicating them. Pushes run only inside durable Scheduled Actions, never inline.

CLI & MCP

SwarmStack is a web app and an MCP surface. From Claude Code you can create a Session, hold a Persona Task, invite a collaborator, and drive the engagement without leaving your terminal — the same server, the same Session, the same durable state.

The MCP tools cover the same verbs a marketplace expert or a creator needs — create, invite, join, poll, view, discuss, answer, complete — so a Task Interview persisted turn by turn on the server reads the same whether it was driven from the web or the CLI.

How it is built

The reliability model is the load-bearing part of the product. Four disciplines carry it:

• Tenant isolation by default. Every domain row carries a tenant id, and Postgres row-level security is forced on every domain table. The application role cannot bypass it; CI fails the build if any table is missing the policy.
• The atomicity contract. Every state mutation runs in one Postgres transaction — lock, validate, update, audit, enqueue — and never calls an external API inline.
• Durable side effects. Async work (an email, a payment, a payout, a timeout, an LLM gate) becomes a Scheduled Action row claimed by the Scheduler with atomic compare-and-set. Nothing important lives in a setTimeout, so nothing is lost on restart.
• Prompt-injection defense. All Participant-authored text is wrapped in an untrusted-content envelope before any model sees it, and an append-only audit log records every state mutation for at least a year.

The full threat model, control catalog, and incident SLAs are on the Security page.

Plans & limits

A Creator's Plan Tier — free, pro, or team — bounds the shape of their Sessions, not a token allowance. SwarmStack bounds the cost of a Session by bounding its Session Envelope: its depth, model class, seat count, and number of Rounds.

• Free is near-solo and capped at three lifetime SwarmPlans (the first on the managed key, then bring-your-own-key), sized so you still complete one full plan and see the contention.
• Pro unlocks unlimited SwarmPlans, GitHub and Jira integrations, the Marketplace, and wider depth, models, seats, and Rounds.
• Team is where the many-humans case lives — shared seats for the whole room in one Session.

See the full breakdown on Pricing.

Where to go next