$ madhouse capture \ --input "self-publishing ebooks as a 2026 side hustle" \ --shape source-of-truth
roadmap · self-publishing side hustle ● building content audit & categorization ✓ done deduplicate source list ○ planned
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.
Six specialized roles shape it in a single guided pass — and you approve every change.
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. Scroll to meet them.
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, so you always have a safe path forward without risk.
Grounded, adversarial scrutiny. It surfaces the most important risk to address next — ranked by consequence, not 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. Click the core to see it break into its roles.
Provision a source of truth, review its roadmap, watch each agent's status, and steer the work — without asking yourself to change how you think. Hover the console.
Fig. 1 · MADHOUSE web workspace| Task | Owner | Marks | Updated | State |
|---|---|---|---|---|
| Content audit & categorization | Forge · Roadmap | 12 | 2m ago | Building |
| Deduplicate source list | Forge · Resources | 8 | 1h ago | Done |
| Draft the launch checklist | Orchestrator | 0 | — | Planned |
| Red Team: pricing risk review | Red Team | 3 | 6m ago | Ready |
A captured idea sits quiet until MADHOUSE shapes it. Flip the switch to watch a static capture come alive into an orchestrated, moving workspace — the same crossfade your source of truth makes real.
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.
MADHOUSE sends only the heavy reasoning to top-tier models and the light work to cheaper ones — capturing that price 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.
Because you connect your own provider keys, you pay the provider directly. There's no platform markup layered on 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. 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.
The moat isn't the model — it's the discipline wrapped around it.
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. 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 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 — they're an edge.
Self-hostable from day one — a starter you run and own, not a seat you rent.
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 — 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 — a clean, modular codebase, not a plugin store.
Credential-blind by design and bring-your-own-key throughout. Run on your own Anthropic, Supabase, and GitHub accounts — provider-swappable, no lock to one 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 — 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 or one-click agent install. 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. 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.