Decode
A transcript is not a system. The second phase of the CORTX method turns what was captured into something an agent can run.
From conversation to schema.
A ninety-minute transcript contains everything and nothing. The work of Decode is to read the transcript several times — slowly — and pull out the structures hiding in it.
A workflow becomes a sequence of steps with inputs, outputs, and conditions. A relationship becomes a routing rule. A piece of vocabulary becomes an entity in the system's data model. An exception becomes a branch.
What was a story becomes a schema. The schema is what an agent reads to know how to act.
Two passes.
The first pass is human. The implementer reads the transcript and extracts what they recognize: named workflows, named systems, named people, named exceptions. They write each one down in their own words.
The second pass is paired with Claude. The implementer's notes go in. The transcript goes in. Claude proposes the schema — the formal structure — and the implementer corrects it. The corrections are where the real knowledge transfers.
What comes out is a draft of the System MCP for that vertical. It is never final on the first pass. It is final after the wizard runs and the employee corrects it from the inside.
Workflows are built from primitives.
Across hundreds of hours of captured workflows, the same patterns recur. We name them. We document them. We use them as the building blocks of every new vertical.
- P-01 instruct_and_validate. The agent tells the human what to do, then verifies the result through an API or screen check before marking the task done.
- P-02 fetch_and_classify. The agent retrieves data from a system, sorts it by type, routes each item to the appropriate workflow.
- P-03 wait_and_escalate. The agent monitors a state for a configured duration, then alerts a named human if the state hasn't changed.
- P-04 capture_and_log. The agent records an event with structured metadata for later audit and for cross-vertical correlation.
- P-05 request_and_confirm. The agent generates a draft (an email, a message, a document), presents it for human approval, then sends.
Every business is different. The primitives are not.
What a Vertical Spec contains.
A vertical spec, when finished, has four nested layers.
- System MCP — the workflows, primitives, and tools for one functional vertical (e.g. insurance billing, procurement, scheduling).
- Org MCP — the customizations that make a System MCP fit a specific organization. Routing rules, vocabulary overrides, tier definitions.
- Employee MCP — the personal layer for each operator. Their authority level, their style preferences, their typical exceptions.
- Vertical MCP — the cross-cutting layer that holds knowledge shared across organizations in the same industry. Built up over time, across clients.
The four layers compile into the agent's runtime context.
From static vault to dynamic plan.
The four MCP layers are static. They sit on disk. They are the long memory.
When work begins, the agent reads the static layers, queries the project state in Plane, and assembles a runtime plan: what tasks are open, which workflow each task belongs to, which primitives apply, which tools are needed, who needs to be instructed.
The plan is rebuilt for every action. There is no cache. The vault is the only source of truth. The agent is just a function that maps vault + state to next action.