MADHOUSE turns a spoken thought, a photo, or a scribbled note into a structured, trackable project — an orchestrated workspace where AI does the shaping and you stay the decision-maker.
Everyone captures ideas. Almost no one has a reliable way to turn a raw spark into something structured enough to act on — before the momentum is gone.
Notes apps, voice memos, and docs are full of half-formed ideas. Capturing is easy. Nothing turns that raw input into a plan you can execute.
General chatbots respond, but they don't hold structure. You get an eloquent answer, not a tracked, evolving source of truth you can return to and build against.
One idea is mostly a prompt for a tool. Another is a sequencing problem. A third is "what do I even need." Nothing diagnoses which — it treats them all the same.
Models are now good enough to diagnose an idea's real shape, ask the right clarifying questions, and maintain a living structure. The workflow was impossible two years ago. It's the whole product now.
You bring the idea in any form. MADHOUSE clarifies it, shapes it, and hands you a workspace you can steer — never a black box.
Type it, paste it, or upload it. However the idea arrived, it goes into MADHOUSE as-is.
→Before anything is built, a front-line AI asks up to four sharp questions — only when the idea is genuinely ambiguous. A clear idea flows straight through.
→The clarified idea becomes a source of truth: original idea, roadmap, and resources — each a living document you can mark and edit.
→Set a goal and get a ready-to-run work order, or propose a change the AI drafts and you approve. Nothing changes without your say.
MADHOUSE isn't one chatbot. It's a small, specialized team — each role with a distinct job, a distinct temperament, and hard boundaries on what it can touch.
Reads the whole project, classifies the idea's nature, and assembles the source of truth — weighting its effort toward what the idea actually needs, whether that's prompts, a roadmap, or resources. It proposes; you dispose.
Suggests the easiest, highest-leverage next step to keep momentum. Advice only — it never edits your documents.
Grounded, adversarial scrutiny. It surfaces the most important risk to address next — ranked by consequence, not by ease. Deliberately different from Pink Team, so you see both the safe path and the sharp one.
Reads your repositories to advise and author fixes — but has no ability to write or deploy on its own. The write path simply doesn't exist in its wiring. Assistance without self-escalation.
A read-only status rollup that reads across your roadmap, marks, and repo to tell you what moved, what's building, what's blocked, and what's next. It reports — it never changes a thing.
Explains MADHOUSE in plain language, on demand. Ask what a role does or how a step works and get a clear answer — so a newcomer is never stuck, and never has to leave the workspace to figure it out.
Each role runs on its own API key and its own model, chosen for the job it does. That's an infrastructure decision most "AI apps" skip, and it's a quiet part of what makes MADHOUSE feel like a team rather than a single assistant.
Heavy reasoning where it matters, fast and cheap where it doesn't — instead of paying premium rates for every call.
Separate keys mean per-role cost visibility and spend limits — one runaway role can't quietly drain the rest.
A revoked or rate-limited key degrades one role, not the whole product. The system keeps running.
Roles resolve their model through a registry, so upgrading a model — or a whole provider — is a config change, not a rebuild.
Most people reach for AI through flat monthly subscriptions, and stack several of them. MADHOUSE runs on your own API keys, metered by actual use — and because each role picks the right-sized model, it spends on capability only where the work demands it.
Idea work is bursty — a flurry when inspiration hits, then quiet. Metered API usage fits that shape far better than a flat monthly fee you pay whether you use it or not.
Premium capability costs many times more per token than a fast model. MADHOUSE sends only the heavy reasoning to top-tier models and the light work to cheaper ones — capturing that gap by design.
One workspace orchestrates several models. You're not paying for a separate seat on every tool just to have the right model available for each kind of task.
Because you connect your own provider keys, you pay the provider directly. There's no platform markup layered on top of your usage.
Honest framing: bring-your-own-key means your cost tracks your usage, so a very heavy, all-day user could spend more than a flat plan — while a typical bursty user usually spends less than stacking subscriptions. The durable advantage isn't a fixed discount; it's that you only pay for what you actually run, at provider rates, with the architecture tuned to avoid paying premium prices for routine work. Subscription figures reflect standard public pricing as of mid-2026 and will change.
Anyone can call an API. What's hard to copy is a system where AI is genuinely powerful and genuinely safe — where every capability is fenced, every action reversible, and every secret protected. That architecture is the product.
A user action never silently triggers an AI cascade, and AI changes to your source of truth are proposed, previewed, and confirmed before anything is written. Every mutation is a single bounded pass — no runaway loops, no black-box edits.
Private keys and values live in a vault that is masked, owner-scoped, and structurally excluded from anything an AI role can see. The agents are blind to your credentials by design, not by policy.
The system snapshots before it acts, so any AI-driven change to your documents can be reversed with one confirmation. Powerful assistance you can always walk back.
The Debugger can read and advise but has no write path. Advisors can suggest but never edit. Capability is granted structurally — an agent can't do what it isn't wired to do, no matter what it's asked.
MADHOUSE grows with you. The same workspace that walks a newcomer through their first idea becomes a power tool the moment you're ready to run it your way.
You don't need to know what a "prompt" is or how any of this works under the hood. MADHOUSE asks you plain questions, shows you the easiest next move, and never changes anything without your yes. You learn the shape of the work by doing it, guided the whole way.
The code exists; the documentation, the status, the "what was I even building here" doesn't. MADHOUSE reads your repositories, tracks where each project actually stands, and keeps a living source of truth so you can pick any project back up without the cold-start tax.
You don't need hand-holding; you need control. Buy MADHOUSE, run it on your own keys and infrastructure, and extend the spine with your own specialized agents. The adversarial roles aren't training wheels for you — they're an edge, surfacing the sharp risks a single assistant would smooth over.
MADHOUSE isn't a walled garden. A technically capable user can stand up their own fully independent instance — their own keys, their own data, gated to their own account. A guided in-app wizard validates each credential and hands off cleanly to deploy.
MADHOUSE is the upstream orchestration and source-of-truth layer other tools plug into — and it's yours to run. You get the codebase, host it on your own infrastructure, and extend the spine: the multi-agent registry is a real extension point, so teams add their own specialized roles instead of being locked to the built-in set.
You get the full codebase and run the orchestration + source-of-truth layer yourself. It's a starter to operate and shape — not a service you rent a seat on.
Each role is a registry entry with its own key and model. Adding one is a registry slot + a key + a prompt — so you extend MADHOUSE with your own specialized agents. A clean, modular codebase — not a plugin store or a one-click install.
Credential-blind by design and bring-your-own-key throughout. Run on your own Anthropic, Supabase, and GitHub accounts — your spend, your data, and provider-swappable, with no lock to a single model vendor.
A documented path, already shipped: a Deploy-to-Vercel button, a guided setup wizard, and an owner-lock that keeps the instance yours. Not vaporware — it's built and running.
Honest framing: "extend it" means code-level extension in a clean, modular codebase with an agent registry and per-agent keys — not a plugin marketplace, an agent store, or a one-click agent install (those don't exist, and we won't pretend they do). Self-host is a starter you run and own on your own keys — not a managed, turnkey hosted product. Licensing and modification terms are set directly with us.
A hosted product for people who want zero setup, and a self-host license for people who want total control. Bring-your-own-key throughout, so usage costs stay with the user.
Self-Host is the first-class offering — you run and own the instance, a starter you operate rather than a service you rent. Pricing shown is directional — the model, not a rate card. Bring-your-own-key means the customer pays their own AI usage, keeping our margins clean. Licensing and modification terms are set directly with us — talk to us.
MADHOUSE is a functioning product, not a mockup — the workspace, the six AI roles, the safety architecture, and the self-host path are all built and deployed. What's ahead is customers, not core engineering.
Honest framing: this is a pre-revenue, pre-traction stage. The pitch is the product, the architecture, and the defensibility — the numbers come next.
The capture market is saturated. The "turn capture into structured, safe, trackable action" market is wide open — and MADHOUSE is already built to own it. Let's talk about what's next.