Architecture · Cognitive Mesh Architecture

How the Cognitive Mesh works.

Three diagrams, in plain language: how a question gets answered, what the memory is made of, and how we know it is working.

01

How a question gets answered.

You talk to one assistant. Specialists do the work behind it — and the platform, not the AI, carries their answer back to you word for word.

The path a question takes

flowchart TB
  OP([You])
  NOLAN["One assistant
knows your history
picks the right helper"]
  SPEC["A specialist does the work
writing · deciding · reviewing"]
  MEM[("Shared memory")]
  OP --> NOLAN
  NOLAN --> SPEC
  SPEC -. "the assistant's summary" .-> OP
  SPEC == "the specialist's exact words,
carried by the platform" ==> OP
  NOLAN --- MEM
  SPEC --- MEM
  class SPEC hot
  class MEM store

AI judges; software delivers. The dotted line is the assistant’s paraphrase. The thick line is the specialist’s actual words, carried by plain software so nothing is lost in the retelling.

The grading that runs on its own

flowchart TB
  TRIG["A schedule fires"]
  CODE["Plain code, no AI
picks what to grade
gathers the context
checks the math"]
  AI["AI grades the work
the only step needing AI"]
  FILE["A recorder files the result
exactly as computed"]
  MEM[("Shared memory
a broken grade saves nothing")]
  TRIG --> CODE
  CODE == "the work + your standards" ==> AI
  AI == "the grades" ==> CODE
  CODE --> FILE
  FILE --> MEM
  CODE -. "reads only, never writes" .-> MEM
  class AI hot
  class MEM store

One AI step, surrounded by code. Choosing what to grade, gathering context, checking the arithmetic and filing the result are all ordinary software. The AI does the one thing only it can do — form a judgment — and everything around it stays verifiable.

02

What the memory is made of.

The mesh isn’t the AI helpers — it’s the connected memory they all read. That’s why its value holds no matter which AI shows up.

The connected memory

flowchart TB
  RULES["Your agreed rules
who set each one, and why"]
  DEC["DECISIONS
what you chose · why
what you rejected"]
  LES["LESSONS
what experience taught"]
  WORK["WORK
what you made"]
  PROJ["PROJECTS
what you're aiming at"]
  AGENT["Any AI helper
one, or fifty"]
  RULES ==> DEC
  LES == "informed" ==> DEC
  DEC == "shaped" ==> WORK
  WORK == "taught" ==> LES
  PROJ --- DEC
  PROJ --- WORK
  AGENT == "reads all of this first" ==> DEC
  class RULES gold
  class AGENT hot

The why survives. Most tools save what you did. This saves why — the options weighed, the rules agreed to, the lessons that shaped the call — and the links between them. Lessons inform decisions, decisions shape work, work teaches new lessons. Every AI helper reads that whole loop before starting, so the fiftieth answer stands on more than the first.

03

How we know it’s working.

No trust required. Plain arithmetic reads the record, the answer has to hold up from four directions, and bad news gets published first.

The proof loop

flowchart TB
  W["Work gets done
and remembered"]
  G["Every piece gets graded"]
  LOG[("The record
entries are never edited")]
  MATH["Plain arithmetic
no AI in the checking"]
  Q{"Is quality
trending up?"}
  YES["YES — provably
and we can show the work"]
  WAIT["CAN'T SAY YET
we wait for more data"]
  NO["NO — and we say
so first, by rule"]
  W --> G --> LOG --> MATH --> Q
  Q == "all four checks agree" ==> YES
  Q -- "checks disagree" --> WAIT
  Q -- "trending down" --> NO
  YES == "what provably works
gets reached for first" ==> W
  class YES goldfill
  class NO hot
  class LOG store

Falsifiable on purpose. The improvement claim is arithmetic anyone can re-run, not a feeling. If it doesn’t hold up from every angle we say “can’t say yet” rather than round up. And the gold line closes the loop: what provably works gets reached for first next time. That is the compounding.

See what it has actually produced.

The diagrams show the mechanism. The evidence page shows the numbers it has produced in the deployment running today.

See the evidence →