Doric runs a closed loop: a team decomposes your intent, a swarm of agents builds it across parallel threads, the system verifies the result against reality, and the architecture map stays correlated to the code. Here is what is actually happening.
Describe what you want. Phoebe maps the product and Theo lays out the data schema, live, as you talk. You review and edit the whole blueprint — and the team only starts building once you say go.
Three specialists hold the project, and the orchestrator fans out helper agents on demand for the actual building. Each agent reads a role-scoped view of one shared project store — not a private chat history — so nothing drifts out of sync.
Every agent works against the shared store and the contracts; their output is tested and written to an evidence log before it counts as done. Effort you can audit, not just trust.
Niko splits a goal into independent development threads, each scoped to a seam with its own contract, and runs them at the same time. When a thread finishes, it reconnects at the seam — a clean integration lands automatically; a conflict stops and asks rather than overwriting.
A feature's status is not a flag an agent sets. It is derived from evidence: a spec exists, the indexer finds the code that implements it, a smoke test passed, it deployed, it was accepted. Only system actors — the test runner, the indexer, the deployer — can emit that evidence.
From parallel threads that don't fragment context and compounding memory, to verified-not-narrated builds, a living map and the Data Gateway — each is something Doric handles for you, and something you'd be doing by hand without it.
See the twenty →Snapshot and fork the entire project — not just files, but the state it was in. Take a thread somewhere experimental, and if it doesn't work, roll back to any prior snapshot and lose nothing else.
Underneath, every version is retained; on the surface you navigate the milestones you chose to mark. When you're ready, the same project deploys to your own cloud through one clean seam — no migration, no lock-in.
Why this matters →Doric knows your dependencies — in the spec and in the code. So any topic can be followed along its full reach: from the decision that shaped it, through the code that implements it, out to every place it's deployed.
Change-impact stops being guesswork. Before you touch a feature you can see its whole blast radius, and after you ship you can see everywhere it landed.
Your app talks to one narrow, Postgres-shaped interface — the Doric Data Gateway — with the real backend behind an adapter. Move from a Firestore preview to enterprise AWS without a rewrite. No proprietary runtime, no lock-in.
And your whole project is one click from leaving — a full export any time. Ownership by export, not by where the files happen to live.
Confidential, regulated or competitive work — every project is fully isolated, sealed and private, with nothing crossing between projects.
Access is enforced server-side, never in the browser; membership is the single gate, written only by the server; logs are secret-scrubbed and files are served through short-lived signed URLs. The platform you can trust with the real thing.
Most AI threads rot: the longer they run, the slower, vaguer and pricier they get. Doric is built the other way — it stays fast, focused and economical as the project grows.
Every turn carries only the least-sufficient context, switches models solely at a cache boundary (where a switch is free), routes to the model that returns the most value, and distils long threads so they never bloat.
Under the hood →Doric exists because building in Cowork, Antigravity and Cursor turns into a mess at any real size. Bring an existing project and Doric gives it a map, contracts and an R&D team — so you can finally grow it.
Start with your project