The Workspace-Brain
The Workspace-Brain
A note on substrate, written the day after the first customer onboarded.
In the last six weeks, three different people drew the same substrate from three different angles. None of us was talking to the others. None of us, until now, was talking publicly.
Garry Tan — the president of Y Combinator — shipped gbrain in twelve days. It is an MIT-licensed, agent-installable personal brain that runs on his laptop, or on his Supabase. It indexes his email, his calendar, his voice notes, his tweets, his meetings. At night it runs an eight-phase "dream cycle" that lints, links, embeds, and consolidates. It is the substrate as a single user lives it.
A week earlier, GitHub Next published two prototypes. Repo Mind builds a graph over a code repository — Tree-sitter parses declarations, Leiden clusters group them, agents query through LSP-shaped tools. ACE is the surface above the graph: per-session microVMs on their own git branches, multiplayer chat where humans and agents share scrollback, plan editing with shared cursors. Maggie Appleton's framing is sharp. Software is a team sport, and individual agent productivity is collapsing planning windows faster than alignment can keep up. The bottleneck is no longer code generation; it is coordination.
I have been building architect at Eleven11 for nine months. It shipped its first paying-shape customer the day before I wrote this. Three coupled loops on one substrate: a thinking surface, an execution surface, and a memory spine. Postgres-16 with pgvector underneath. Sovereign per-tenant — the customer gets their own box.
Three different shapes. One substrate underneath all of them.
That is the part I want to talk about.
Three geometries
Garry's gbrain is the substrate at the single-user pole. One person, one brain, one machine. The corpus is your life. It self-wires, it ships as code, and it lives on your hardware.
GitHub Next's Repo Mind plus ACE is the substrate at the dev-team pole, split in half. Corpus understanding on one side; multiplayer surface on the other. The split is not arbitrary. GitHub's distribution model is code, and code teams are big enough that the codebase and the meeting room are different artefacts. Both halves are right; both are also bound to a corpus that has to be git-shaped.
Architect is the substrate at the per-tenant workspace pole. The corpus is whatever a knowledge-work team produces — matters, asks, audit findings, calendar events, customer correspondence, calibration outcomes. The substrate runs on the customer's own box, not in a shared cloud. The corpus and multiplayer halves of GitHub Next's bet collapse back into one primitive on this wedge, because the operate loop — matter-anchored asks with billing buckets, plus a calibration layer — is what holds them together.
These are not three implementations of the same product. They are three different geometries on one substrate. Each owns its corner. None can swallow the others; the geometries do not bend that way.
What architect actually is
Architect runs three loops on one substrate.
The first loop is Architect — the thinking surface. An infinite canvas of tiles and connectors, plus a lockable session editor. It is where ideas form before they commit to a matter.
The second loop is Operate — the execution surface. This is where the work actually happens. Matter pages anchor everything. The :ask primitive is the verb you reach for most: type a question inside a matter, watch the system pull from the memory spine, run a grounded LLM call against retrieved units, grade the answer against verifiable rules, retry once if it fails, surface the result for human review if it disagrees. The graded answer becomes a memory unit visible to future recalls. Asks have lifecycle states and billing buckets, because work is the unit of accountability — not text.
The third loop is Remember — the memory spine. Typed memory units, embedded, graph-connected, recall-grounded. Every move in the other two loops lands here, and shows up in recall the next time it is relevant.
The three loops are isomorphic at the substrate level. They share types, retrieval, grading, graph. A locked session writes a memory unit. An ask recalls memory units. A canvas ingest tile promotes to a matter. The connective tissue is the spine; the spine is the product.
The substrate is also opinionated about calibration. Before it shows you the answer to an ask, the system asks you to predict your own grade. Over time, it tells you which classes of question you systematically over- or under-estimate yourself on. That feedback shapes how you ask next time. It is a small thing that becomes load-bearing once you have used it for a few weeks.
Above this, every tool in the Eleven11 fleet — calendar, outreach, security audit, content pipeline, attack-surface intelligence — exposes itself through one widget contract. Architect is the canonical reader. The fleet flywheel is the consequence of the contract, not a separate decision.
The wedge
Each pole owns its corner because of how it is shaped, not because anyone said so.
Gbrain owns single-user. MIT-licensed, agent-installable, runs on your laptop. The brand is the moat — Garry's personal brain is the distribution. It does not want team-scale tenancy. It does not want a billing surface. It is the opinionated personal-brain pole, and it owns that pole cleanly.
GitHub Next owns dev teams. Their distribution model is code. The moment either of their tools points at a corpus that is not git-shaped — which is the actual workspace of every non-code team on earth — the abstractions stop carrying. The right primitive for a healthcare integrator's day is not a commit. It is an audit finding traced to an FHIR endpoint, anchored to a customer matter, attached to a regulatory deadline. Same memory-unit type, different corpus.
Architect owns per-tenant workspaces. Three things make this its own pole, not a copy of either of the other two.
The first is tenancy. The customer onboarded this week runs on his own server, his own Postgres, his own keys. No shared multi-tenant database. The platform plane cannot read his data. For ABDM, healthcare, financial services, government, this is not a feature; it is the only acceptable posture. Neither single-user-laptop nor GitHub-cloud-microVM can match it.
The second is corpus. Same primitive as gbrain — typed records, embedded, graph-connected. Different corpus shape. Where gbrain pulls from your email and tweets, architect pulls from matters, asks, audit findings, customer correspondence, and the widget producers across the Eleven11 fleet.
The third is operate. Gbrain builds the Remember loop, beautifully. Repo Mind builds Remember for code. ACE builds the Architect (planning) loop. None of them builds Operate. There is no concept of an ask with a billing bucket, no calibration on prediction-vs-outcome, no matter-anchored lifecycle, no agency-engagement surface. Knowledge work — unlike software development, unlike personal life — collapses planning, execution, and billing into one motion. Architect's substrate collapses them by construction.
On building in the dark
The convergence is real, and it is not coincidence. Three independent shipments in six weeks is what happens when several people, each working alone for their own reasons, finally stop being early.
Substrate gets discovered by people who need it for themselves long enough that the joins start to load-bear. You cannot trend-follow your way into substrate. You can only trend-follow your way into commodity outputs of substrate that someone else already discovered.
Garry built gbrain because he needed it for his own life and his agents. GitHub Next is prototyping Repo Mind and ACE because their internal teams need it for theirs. I built architect because I needed it for a fleet of nine tools that had to share memory, for an agency-engagement surface that had to track asks against billing, for a research practice that needed calibration. None of us was building for an imagined market. We were each building for ourselves first.
That is the only honest way to find substrate. Trend-followers cannot see the joins because they have never had to load-bear on them. Garry's gbrain wires itself with five hard-coded edge types because those are the edges his life actually has. Repo Mind clusters with Leiden because that is the granularity at which a code corpus actually folds. Architect tracks asks with billing buckets because that is what an agency engagement actually demands.
What is next
The substrate is now collectively-acknowledged-real, and the lanes are forming. Garry owns the open-source single-user pole. GitHub will solve the dev-team-cloud flavor, and they will solve it well. Architect's pole is the per-tenant sovereign workspace with the operate loop attached. None of us will see each other in our lanes.
Architect is not SaaS. It ships per-tenant — your own box, your own data, your own keys. BYOK on every model and embedding provider. The platform plane is operator-controlled but the tenant plane is yours.
If the substrate question is interesting to you — if you build, fund, or live inside knowledge work that has outgrown shared-database SaaS — I would like to hear how you would break the model. There is a tenant box waiting for you if you want to live inside it for a week and disagree from the inside. That is the only honest way to evaluate a substrate claim.
The dark-building is over. The daylight starts here.
Loom walkthrough: recording forthcoming Direct: [email protected] Eleven11: eleven11.pro
Sister substrates:
- gbrain (Garry Tan) — github.com/garrytan/gbrain
- Repo Mind — githubnext.com/projects/repo-mind/
- Repo Mind Light — githubnext.com/projects/repo-mind-light/
- ACE (Maggie Appleton, GitHub Next) — The Case for Collaborative AI Engineering
Eleven11 is a brand under AilyakEleven Experiences LLP. Operator-controlled. Customer-controlled. Your control.