Agents
An agent is a named operator backed by an AI model. It picks up tasks, calls tools, talks to humans, and is accountable for what it produces.
Not a chatbot. An operator.
A chatbot answers a question and forgets. An operator picks up a task, sees it through, hands off when needed, and is accountable for the outcome.
An agent in CORTX is the second kind. It has a name. It has a defined role. It has a set of workflows it owns and a set of tools it can use. It interacts with humans through Flow — the cockpit — using plain language, and with systems through tools. The work it does is logged, traced, and auditable.
The agent is not a generic AI assistant. It is a specific operator built for a specific function in a specific organization.
What an agent is made of.
An agent is not a model. It is the model plus the four things around it.
Read. Plan. Act. Validate.
The agent runs a loop. It reads the open tasks assigned to it. It selects the next task. It loads the relevant MCP context. It plans the action. It calls the tools needed. It validates the result. It updates the task. It moves to the next.
The loop is small. The loop is observable. The loop is the same in every deployment. What varies is the workflows, the tools, the context, and the operators in the loop.
Tasks are not done until they are verified.
An agent does not mark a task done because it tried. It marks a task done after it verifies — through an API check, a screen read, a database query — that the result happened in the system of record.
If verification fails, the task stays open. The agent retries, or surfaces the issue to a human, or escalates. It does not lie. It does not pretend. It does not skip ahead.
This is the operational difference between a demo and a deployment.
When the human gets the case.
Most tasks an agent runs do not require a human. The agent acts, validates, completes. The human sees the result rolled up in the case timeline.
Some tasks require human judgment, human approval, or human action in a system the agent cannot reach. For those, the agent prepares everything — the data, the context, the recommended action — and hands the case to the operator through Flow. The operator decides. The agent picks back up where the operator left off.
The handoff is explicit. The state is preserved. Nothing is lost between agent and human.
Named operators, not a black-box workforce.
An operator who can be named, scoped, audited, and overridden is fundamentally different from an opaque AI workforce. The first can be deployed responsibly. The second cannot.
Every agent in CORTX has a name, an owner, and a defined scope. Operators know which agent did what. The audit trail records every action. Errors can be traced to the responsible agent and the specific decision that produced them.
At the center.
The agent sits at the center of the architecture. It reads from MCP. It writes to Plane (the workflow ledger). It calls tools. It talks to humans through Flow. Every other building block exists to support the agent or to be acted on by it.