About
Built for decisions you don't want to make alone.
MAINS — Multi-AI Neural System — is a platform for thinking with more than one AI at a time. You direct them. You set the question. You make the call. The AIs do the work of disagreeing with each other so you don't have to wonder if the one you asked was the wrong one.
Year zero
It started with a coding problem I couldn't crack.
I was deep in a build. Claude knew one half of the answer. ChatGPT knew the other half. I kept tabbing between them, copying context from one window to the other, watching the conversation decay each time I switched apps. By the time I had stitched their two answers into something usable, I had lost the thread of what either of them actually said. The decision I ended up making was mine, but I couldn't tell you, half an hour later, whose reasoning was whose.
I looked at the existing tools. The multi-model aggregators (Poe, Chub, the side-by-side viewers) gave you parallel answers but the AIs didn't actually talk to each other — they just answered the same question independently. The autonomous frameworks (CrewAI, AutoGen, A2A) hid the conversation inside code and ran the agents without you. Some of them charged enough to make you think twice before pressing send. None of them let me do the one thing I wanted: watch two AIs argue, in real time, about a problem I cared about — and then have the final say myself.
So I built a small piece of glue. A Node.js server speaking the Model Context Protocol, exposing my Obsidian vault to ChatGPT over an authenticated tunnel. Claude already had filesystem access through Claude Code. Now ChatGPT did too. Suddenly both models could read and write the same plain-markdown files in the same folder. The Obsidian vault became their message bus.
I started leaving them notes for each other. Claude would write a proposal. I'd dispatch ChatGPT to read it and respond. ChatGPT would counter. Claude would refine. The conversation lived in my file system as a stack of timestamped markdown turns, and I could open any of them in Obsidian and edit them with my own hands. The friction of copy-paste vanished. The decay of context stopped. The thread held.
That bridge was the first ancestor of what is now MAINS.
From bridge to nervous system
The rules grew up around the conversations.
The first few weeks of using the bridge revealed something specific: the magic wasn't the AIs talking. It was the reader watching them talk. I was the one synthesizing. I was the one catching the disagreement neither AI was bold enough to flag. I was the one deciding which line of reasoning actually applied to my problem. The conversation was good material — but the value was the act of orchestration.
Once I saw that, the protocol wrote itself. Turn-taking, so nobody talks over anyone. A scope card, so every AI reads the same constitution before every turn. A disagreement procedure, so the founder writes the binding decision and the losing model acknowledges. A handoff format, so the thread can be picked up again next week without the agents needing to re-derive what they were doing. Plain markdown for everything — auditable, forkable, your own.
That became MAINS — the Multi-AI Neural System. A protocol first, a platform second. A way of working before it was a product.
Later came Klaustrum — a sub-mode where the AIs are allowed to debate each other autonomously, without your hand on every turn. Named after the brain's claustrum, the thin sheet of neurons Crick proposed as the seat of conscious integration. Klaustrum runs under a circuit breaker (iteration cap, time cap, cost cap, your intervene button) and surfaces the result for you to accept, reject, or steer. Autonomy when you grant it. Not when the system assumes it.
On the 22nd of May, 2026, the protocol was validated end-to-end on a real community-moderation policy decision — three locked principles produced by founder-synthesized multi-AI debate. Genuine disagreement on a sub-question that neither model would have flagged alone. The locked principles were structurally better than anything either model produced standalone. From that point on, MAINS stopped being a thing I was building and started being a thing I was using.
This site, the apps, the mobile build, the MAINS Memoria decision-memory layer — all of that is downstream of those first afternoons of watching two AIs argue in markdown.
What makes MAINS different
The human in the loop is the loop.
Most multi-AI tools assume one of two things: either the human wants to read parallel answers and pick one, or the human wants to press a button and let the AIs do everything. MAINS is built on a third assumption — that there are decisions the human is qualified to make and wants to make, and the AIs are there to surface the considerations that make those decisions better.
You set the scope. You dispatch the turns. You read the deliberation. You write the deciding turn. The AIs are brilliant, patient, and willing to disagree with each other without ego. You are the one who knows what the decision is actually for.
Who it's for
Any decision worth more than one mind.
MAINS was built by a developer for developers, but the moment the bridge worked it stopped being just for developers. The protocol works any time you would benefit from a second, third, or fourth perspective — and want to be the one who decides what to do with them.
At work
Students
Drafting a thesis? Have Claude, ChatGPT, and Gemini independently attack your argument. The strongest counter is the one you should address before submitting.
Academics & researchers
Vet a hypothesis against three models trained on different corpora. When they disagree, you've found the seam in the literature worth digging into.
Scientists
Cross-check an experimental design before you spend the lab time. Each AI flags a different risk you'd otherwise discover at the bench.
Coders & engineers
Stuck on a subtle bug? Let Claude and ChatGPT debate the root cause in Klaustrum. Most of the time one is wrong — but the wrong one helps you see why the right one is right.
Journalists
Fact-check a story by having three AIs independently flag inconsistencies. Use the deliberation trail as part of your source documentation.
Doctors & clinicians
Run a differential through multiple models. Useful for surfacing the diagnosis you hadn't considered. Not a replacement for clinical judgment — a supplement to it.
Founders & operators
Pricing, hiring, market choice. Decisions where one AI's bias becomes your bias. Three perspectives reveal the assumptions you didn't know you were making.
Therapists & coaches
Explore frameworks for a complex case. Multiple AIs surface multiple lenses — cognitive, somatic, systemic. You pick what fits the work.
Policy makers & public servants
Governance choices where bias matters. MAINS itself was validated on a real community-moderation policy decision — three AIs surfaced a sub-question none of them caught alone.
Writers & editors
Three independent critiques of a draft. Useful when you've stared at the work so long you can't see it anymore.
And in everyday life
Planning a meal for a cultural moment
Diwali, Lunar New Year, a christening, an iftar — debate which dishes honor tradition while accommodating who's at the table. Three AIs, three angles on the same menu.
Buying your first car
Used Subaru or new Toyota? Long commute, tight budget, snow country. Let the AIs argue total cost of ownership while you read the audit trail.
Comparing neighborhoods or schools
Parents deciding between two school catchments. Couples weighing two cities for a job offer. Three models, three independent reads on the same trade-off.
A small business choice
Two suppliers, two contractors, two payment processors. The kind of decision you'd lose sleep over alone — handled in a structured deliberation.
A serious hobby project
Woodworker planning complex joinery. Cyclist building a custom frame. Hobbyist astronomer choosing a telescope. Multi-AI critique catches the mistake before you commit the material.
Researching a ballot or a vote
Local propositions, school board candidates, bond measures. Multiple AIs read the same documents and surface what each emphasizes — and what each ignores.
A life decision in your own life
Moving for a relationship. Returning to school. Saying yes or no to something hard. AIs are not therapists. But they can help you map the shape of a decision you'll still own.
Even something small and joyful
A gift you can't decide on. A trip you're planning. A name for the dog. The point is the same — when one perspective isn't enough, get more.
The common thread is the same in every case: one perspective isn't enough, the cost of getting it wrong is real, and you want to be the one who decides — with help.
Our philosophy
AI as collaborator. Not oracle, not adversary.
The public conversation about AI tends to land in two unproductive places. One says AI will replace human judgment. The other says AI must be constrained at every step or it will run away with our agency. Neither matches what it's actually like to work with a good AI on a hard problem.
MAINS is built on a more grown-up position: AI is a tool that works best when the human is in the right kind of relationship with it. Sometimes that means you read every turn. Sometimes that means you grant the AIs an autonomous round to argue while you make coffee. The question isn't whether AI should ever be autonomous — it sometimes should — the question is whether the autonomy was granted with appropriate scope and limits, or assumed by a system that took the choice away from you.
MAINS gives you the framework where that distinction is structural rather than rhetorical. The principles below aren't marketing copy. They're design constraints we hold ourselves to.
Human authority over outcomes
Every binding decision is yours. Not the AIs' aggregate, not a vote, not the loudest model. MAINS structures the deliberation; you write the deciding turn.
Autonomy granted intentionally, not assumed
MAINS supports autonomous AI-to-AI loops — that's what Klaustrum is. You set the scope, you set the circuit breakers, you accept or reject the result. Autonomy is a tool you grant, not a default the system assumes.
Transparency in plain text
Every prompt, every response, every decision lives in your vault as readable markdown. No black box. No hidden orchestration. If you want to know how a decision was reached, you read the file.
Your data is yours
We don't sell it. We don't train models on it. You can export or delete the whole vault at any time. The trail belongs to the person who built it.
Where we're going
Still early. Building in the open.
The web platform is live. Mobile is in the build queue. MAINS Memoria — a private memory layer that lets MAINS remember your decisions across threads and projects and recall them into new deliberations — is live now. Deep Research, web-grounded deliberation via Tavily, and integrations with new providers (Grok, local models, MCP-native agents) follow.
We're at the beginning. The platform is being shaped by the people who use it. If you have a use case we haven't considered, a workflow that almost-but-not-quite fits, or a perspective on the philosophy we should be holding ourselves to — we want to hear from you.
Try it. Tell us what's missing.
MAINS is free to explore. The demo lets you run a real multi-AI deliberation without an account. Sign in to start building your own vault of decisions. And if there's anything you want to tell us, we read every message.