Architecture
Built to outlast its own components. The structural decisions that make CORTX work today and will keep working when the components change.
Three layers. That's the whole architecture.
CORTX is built on three layers. Every project, every vertical, every customer uses the same three. Nothing else has been added in two years of building, and nothing else needs to be.
Read the vault. Query Plane. Run a CLI. Update Plane. Repeat.
Every agent is a file tree.
The agent does not store its memory in a database. It does not have an opaque state. Its memory is a directory.
When the agent boots, it reads the directory. The directory has files for the system, for the organization, for each operator, for the active vertical. The files are versioned. They can be inspected, diffed, audited, rolled back.
This is the simplest possible architecture for an agent. It is also the only one that survives the next change in AI.
What lives in the vault.
- System MCP — workflows and primitives for a vertical
- Org MCP — organization-specific configurations
- Employee MCP — personal layer for each operator
- Vertical MCP — cross-organization knowledge for an industry
The vault is a directory on the customer's machine. It is encrypted at rest. It does not leave the building. It is the customer's intellectual property, not ours.
Four steps. That's the whole loop.
- 01
Read the task.
The agent picks up an open task from Plane.
- 02
Load context.
The relevant MCP files are loaded into the agent's context window.
- 03
Run tools.
The agent calls the CLIs needed to do the work.
- 04
Update state.
The result, the validation, and any exceptions go back into Plane.
The loop has run hundreds of thousands of times. It has not changed.
The CLIs are the abstraction.
Every external system the agent talks to — a CRM, an insurance portal, a messaging service — is wrapped in a CLI. The agent does not know what is on the other side of the CLI. It just calls it.
When the underlying system changes, we change the CLI. The agent's behavior does not change. When a new AI model arrives with new capabilities, those capabilities become new CLIs. The agent's architecture does not change.
This is why we have not had to rebuild anything. The architecture is older than the components. It will outlive the components that are in it today.
What we deliberately don't use.
- No LangChain, no SDKs, no agent frameworks. Direct calls only. We own the loop.
- No vector database for memory. Memory is files. Files are diffable. Vectors are not.
- No vendor lock-in. Every external dependency is wrapped in a CLI. Replacing the vendor changes one file.
- No cloud agent. The agent runs on a machine the customer owns, in a place the customer controls.