a second brain with a governing body

One life. 278 systems. Drawn as a sky.

This is a real screenshot of Macrothought running. Every note, project and tool one person owns, mapped as a living constellation and governed by a pipeline that verifies work before it ships.

REQUEST A WALKTHROUGH no product tour videos, just the live system
0
systems mapped
0
living notes
0
gated releases
0
skills
0
departments

Nothing on this page is a mockup. Every image is captured from the running system; every number is read from it.

in plain english

What is this, really?

Everything you know and work on, from notes and projects to plans and to-dos, in one organized place you can see instead of scattered across a dozen apps. Think of it as a second brain with a built-in fact-checker. No jargon required.

one place

Everything, on one map.

Your notes, projects and plans become a visual map, where each part of your life or work is its own cluster you can explore. Nothing scattered, nothing lost.

it checks itself

“Done” means done.

When AI does a task, a second AI tries to prove it's wrong and fixes what's broken before the work counts as finished. The bar is verified, not "the AI stopped typing."

honest

It admits what it doesn't know.

Every fact is marked confirmed, guessed, or unsure, dated and re-checked over time. It tells you what's stale or missing instead of making things up.

private & yours

Your brain, on your terms.

Sign in with a link, no passwords. Prompts run on private infrastructure, not handed to big tech. Your knowledge stays plain text you can read, search and take with you.

That's the whole idea. The technical detail is below, if you want it.

the tree layout

Knowledge grows.

Switch the map to TREE and each department grows upward from a shared root. A game project, an AI stack, a teaching archive: each one changes week to week, and you can watch it happen.

Macrothought tree layout, departments growing as trees of linked notes

TREE layout, live capture. Left to right: a game in development · the AI stack · emulation · tools · NAS · editor · personal, all rooted in one markdown vault.

Force layout, each department a galaxy orbiting the core

FORCE layout. The same vault as living galaxies. Every department is a cluster orbiting the core, and you can drag them and watch them re-settle in real time.

The whole vault as a 3D sphere, live and rotating. Flip on 3D and the entire map wraps around a ball you can orbit, spin and read at depth. Departments can also grow into their own 3D cylinders.

the map, in motion

Watch the whole thing move.

A real screen recording, no edits. Layouts glide from one into the next, the vault wraps into 3D, and focusing one corner pushes the rest into place.

Live capture. Force galaxy, circle, rings, tree, the 3D cylinder and focus, all from one markdown vault.

the consulate · the governing body

Verified, or it doesn't ship.

Most AI tools end when the model stops talking. Macrothought keeps going. Its orchestration layer turns your intent into verified, gated releases. Your map isn't a search box bolted on the side; it feeds every stage, from the context a task is handed to the checks it has to pass. An agent finishing its turn is only the first step; the work still has to clear those checks before it counts.

intent requirements context routing execution verification adversarial audit repair release gate metrics

deterministic spine

No model in the loop. The requirement ledger, verification harness and release gates are plain state and plain code. Completion is provable, not asserted.

local intelligence

Cheap and idempotent. Local models classify, compile context and propose simple fixes. They propose, they don't decide. It all runs on the desk.

frontier intelligence

Where judgment matters. Frontier agents take design, hard repair and adversarial audit. Everything they claim is re-verified by the spine.

explainable routing

Every decision shows its work. Whether a job runs local or frontier, alone or as a swarm, is chosen from its shape, risk and context size, and the reasoning is recorded. You can always see why a task ran where it did.

Usage dashboard · tokens, sessions, activity and models measured over time

Everything gets measured. Tokens, sessions, activity and which models did the work, tracked over time. If you can't see it, you can't govern it.

the governing body · in motion

How “verified” actually works.

The maps above are real captures. These four are the honest opposite: line-art schematics of what the governing body does under the hood, where there is no single screen to film. Diagrams, drawn plainly as diagrams.

the pipeline

Intent becomes a gated release.

intent context route run verify audit gate
A finished agent is step one. The work still has to pass its checks and an audit before the gate opens.
adaptive routing

Cheap by default, frontier when it matters.

task router frontier · hard local · routine
Classification and context-building run on cheap local models on the desk; only hard, high-risk work reaches a frontier agent.
confidence

Every fact knows its own state.

guessed verified stale re-checked
Confirmed, guessed or unsure, dated and re-checked over time. It surfaces what is stale or missing instead of bluffing.
independent audit

A second AI tries to prove it wrong.

build refute repair re-verify gate
When AI finishes, an independent agent tries to refute the work. What survives is repaired and re-verified before it counts.

Schematics, not screenshots. The live pipeline, ledger and gate run in the Consulate; these draw the shape of what they do.

the efficiency

Ask your notes. Pay for a sentence, not a library.

A real test on this vault: 249 notes, about 180,000 tokens of knowledge. Eight real questions, measured with the recall tool that ships with the system.

Macrothought recall635 tokens
the answering section, located for free
Standard chat, your notes pasted in180,700 tokens
no memory of your files, so it carries the whole vault to answer one question
Macrothought
Standard web chat
Tokens per grounded answer
635the answering section
180,700carries your whole vault
Finding the answer
47ms · 0 tokensdeterministic search
no searchre-reads all pasted text
Right source
96% right notecites the note & its date
no memoryof your private files
A 20-turn work session
~13k tokensflat, per turn
~3.7M tokenshistory re-sent each turn
Token cost, 100 answers
$0.19at $3 / million in
$54at $3 / million in
Your knowledge
yours, plain texton private infrastructure
in their chatsent to the provider

Measured across 27 real questions on the live 249-note vault. Accuracy is whether recall opened a note that answers the question (one miss, one question excluded because only the gate's code holds that answer, not a note). Finding the answer is deterministic, so it costs zero model tokens. Dollar figures assume $3 per million input tokens, a mid-tier model rate. The 180k bar is the honest worst case, when you paste everything because you don't remember which note holds the answer. Hand a chat the single right file instead and a prior head-to-head still measured about 10x fewer tokens, because recall returns the section, not the whole file. And a chat re-sends its full history on every turn, so the longer you work, the wider the gap grows.

feature by feature

What's included vs a chat window.

A standard chat is a fine place to talk to a model. Macrothought is where your knowledge lives, gets verified and stays yours. Here is the honest breakdown, including the rows where a plain chat still wins.

Feature
Macrothought
Standard chat
Remembers your private notes across sessions
A visual map of everything you know
Retrieves the exact note that answers you
Brings your existing AI chats into your brain
Verifies AI work before it counts as done
An independent audit tries to disprove the work
Confidence labels and dates on every fact
Tells you what is stale or missing
Cites the source for its answers
Prompts run on private infrastructure
Your knowledge is plain text you own and export
Runs on your own machine
Sends only the relevant slice, not everything
Routes routine work to cheaper local models
Shows why each task ran on the model it did
Open-ended general conversation
Chat history you can revisit
The latest frontier model with zero effort
Ready to use in seconds, nothing to set up

partial or limited. A standard chat wins on instant setup and always running the newest model. Macrothought routes to those models when a task needs them, and adds the memory, verification and privacy a chat window has no way to give you.

what a governed brain is for

Files are the foundation. The point is your work.

The same pattern fits anywhere knowledge decays faster than people can keep up: one readable vault, confidence you can see, and releases that are verified before they ship.

A 40-PERSON COMPANY
Ops knowledge lives in one vault instead of six wikis nobody trusts. When a process changes, the note is updated, not appended, and the release gate means the runbook that ships is the one that was verified. onboarding drops from weeks to days.
A TEACHER
A curriculum as a living department: lessons wikilinked to standards, past cohorts' stumbling points tagged [uncertain] until re-tested. Recall is gap-aware, so it tells you what's stale before you teach it again. prep from the map, not from memory.
A CONTENT CREATOR
Research, scripts, footage and renders mapped as one tree per series. The pipeline treats an episode like a release: drafts don't ship until the checks pass, with sources cited, assets in place and the cut verified. the archive becomes the studio.
A HOUSEHOLD'S FINANCES
Decisions recorded with their reasoning and confidence at the time, then re-checked on a weekly verify-or-decay cadence instead of trusted forever. No advice and no black box, just an audit trail you can read in plain text. every claim dated, every claim checkable.
the machine · governance you can see

Every file. Every change. Reviewed.

The machine view, a file constellation of the whole home directory

The machine view: the whole working environment as a constellation, with amber marking what changed in the last 48 hours.

The machine map in 3D, thousands of files wrapped around a sphere you can orbit

The machine in 3D. Flip the same file constellation into a sphere and orbit the whole home directory, thousands of files read at depth.

The brain travels; the hands stay home. The whole system mirrors to a small always-on server and is reachable from a phone over a private network: maps, stats, history and consoles.

Remote work is reviewed like a pull request. Changes made away from the desk aren't auto-committed. They queue with a summary and file list, and land only on a one-click local review.

Remote changes tab, pending changes reviewed and committed locally

⇄ remote tab, live capture. A pending remote changeset and its commit history.

the philosophy

Memory you can audit.

01

Markdown first. Databases, graph stores and vector memories were tried, then parked. The institutional memory is text a human can read, diff and version.

02

Confidence is explicit. Every claim is tagged [verified] [inferred] or [uncertain], dated and re-checked weekly.

03

Gap-aware recall. Answers say what's stale and what's missing. A system that hides its gaps can't be trusted.

04

No queue without a drain. Every automation that accumulates work has a routine that consumes it. Machinery that only grows is machinery that rots.

where it's going

From a system I run to a service you own.

Macrothought is a working brain today, not a promise. Here is the honest path from hands-on setup to a hosted product. Nothing here is dressed up as live before it is.

available now

Expert setup, done with you

A live walkthrough, a working session, or a full build on your own machine: the vault, maps, routines and governed pipeline, designed around your work. Purchasable below today.

in build

Your own hosted second brain

A managed, governed vault we host and maintain, with prompts run through private infrastructure. Your own workspace, your own usage, isolated from everyone else's. The payment gate, per-tenant isolation and metering are built and independently audited. Isolation is by construction, not by promise: a member's view can carry only their own workspace fields, and the operational internals behind an answer stay operator-side, checked by a test that fails if they cross over. The public service goes live once storage, disclosure and the secure edge are in place.

A member workspace, your own plan, usage and billing, private to you

Your workspace, preview. Your own plan, usage and billing, private to you. Nothing shared with other members.

Building in the open. Want the current state or to shape what ships next? Get in touch.

work with me

Get a brain like this. Built for yours.

This is the same system you've been scrolling through, designed around your life and work. No course, no template drop.

intro walkthrough
Free
20 minutes · live

A real-time tour of the running system and an honest read on what it could look like for you.

BOOK A WALKTHROUGH
working session
$120
90 minutes · screen-share

We design your vault structure, rings, departments and routines together. You leave with a map of your system and the exact next steps to build it.

BOOK A SESSION · $120
estate setup
$499
first five, then $1,299 · fully async · 5-10 days

Built on your machine, end to end: department memory, verification with a planted-defect test, routines, a mini brain-map of your vault, and 30 days of Q&A. Closes only when four acceptance checks pass with evidence, run by you.

READ THE TERMS & BUY

Secure checkout by Stripe · card, Apple Pay, Google Pay · prefer an invoice for your company? Email for invoicing.

about

One person. One real brain. Now yours.

Macrothought isn't a pitch deck or a wrapper around someone else's model. It's a system built and used every day to run real work, from game development to an AI stack to a business, all from one markdown vault with a governing body that verifies work before it ships.

built, not theorised

Every screenshot on this page is the live system. The pipeline that gates a release here is the same one you'd get. Nothing is a mockup.

owner-operated

No VC roadmap, no growth theatre. Features ship when they're correct and get cut when they aren't, the same discipline the product enforces.

yours to audit

Your knowledge stays plain text you can read, diff and export. The system tells you what's stale or uncertain instead of pretending to be complete.

contact

Talk to a human.

Questions, a walkthrough, an invoice for your company, or just to see it running. Email reaches a real person, usually within a day.

macrothought.org · a governed second brain, built in the open.

see it running

The best demo is the real thing.

A walkthrough is the live system on a real screen, not a deck.

REQUEST A WALKTHROUGH