Five stations: intake, plan, execution, independent review, report. An agent does not "answer a question" — it accepts a task with readiness criteria, breaks it into steps on its own, keeps a trace of every action, and returns an artifact you can verify. Below is how this pipeline is built and where it plugs into the AI CEO cycle.
Target architecture · zero implemented
01 · Pipeline
An agent starts not with a model but with a route. The task enters the intake station with readiness criteria, passes through planning, execution and independent review, and only then becomes a line in the owner's report. A skipped station is not an "optimization" — it is a hole in accountability. The diagram below shows which artifact is born at each one.
Demonstration. The moving packet on the diagram visualizes the route — it is not a working agent: the pipeline code does not exist. The diagram honestly switches to a static frame under prefers-reduced-motion and falls back to the SVG version when Canvas is unavailable.
IN · 1/5
The agent receives a subtask from the AI CEO together with context: what is already known, what result counts as done, and which autonomy grade it operates under. Without readiness criteria the task never enters the pipeline — it goes back for clarification instead of being executed "as understood".
in: subtask + context
out: accepted assignment
PL · 2/5
The agent breaks the subtask into steps, assesses the data and tools it needs, and fixes acceptance criteria — before the work starts, not after. That is what separates a plan from an excuse: criteria written in hindsight always match the result.
in: accepted assignment
out: plan + acceptance criteria
EX · 3/5
The agent performs the steps and writes a trace of every action: what was done, on which data, with which tool, and what intermediate result was obtained. If a step needs another department, the artifact is handed over — nobody fakes a colleague's work. Missing data stops execution and turns into an escalation.
in: plan
out: artifact + trace
RV · 4/5
The result is checked against the plan's criteria by a separate role — not the one that produced it. An agent cannot accept its own work: this is an architectural rule. The review returns either a "accepted" verdict or a list of findings, and the task goes back for rework instead of into the report.
in: artifact + trace
out: verdict or findings
RP · 5/5
The AI CEO folds the results of all departments into a single answer: what was done, what was not and why, which decisions need a human. The agent contributes its part — an honest status for its area of responsibility, not a default "all good".
in: accepted artifact
out: owner summary
02 · Anatomy
The pipeline is the route. But for anything to travel it, the agent needs four layers: a goal, memory, tools, and a control loop. Remove any one of them and the remaining three collapse into an ordinary chatbot with a beautiful description.
The agent knows why it was started and what counts as "done". The goal arrives from the AI CEO's subtask together with measurable criteria — not "make it nice", but "return a list of N items with a cited source for each". Without a fixed goal there is nothing for the review to check against, and the pipeline degenerates into text generation.
Layer 1/4 · not implementedThe agent does not start "from scratch" every time: regulations, past decisions, company vocabulary, and task history are stored alongside and available to the next executor. That is what distinguishes a department from a pile of one-off chatbot queries — and it is memory that keeps the agent from reinventing an already-made decision.
Layer 2/4 · not implementedThe agent acts through more than text: it reads data, calls integrations, produces documents. Each tool has its own autonomy grade. Reading is always available, changes inside the system follow the plan, and irreversible external actions happen only with human confirmation. Permissions are declared explicitly — never "everything allowed by default".
Layer 3/4 · not implementedEvery action leaves a record, and the result is checked by a separate role. The trace answers "what exactly was done and on which data"; the review answers "does it meet the criteria". Together they make the agent's work verifiable: the owner sees not "the agent says it did it", but the artifact, the trace, and the verdict.
Layer 4/4 · not implemented03 · Link to the AI CEO
The agent does not take tasks directly from the owner and does not report around the center. It is an executor inside the AI CEO cycle: it receives a subtask after decomposition, returns an artifact, passes independent review, and hands its part into the summary report. Below are the five stages of the cycle and the agent's role at each.
Stage
The owner states the task to the AI CEO: what result is needed and by when. The agent does not participate at this stage and never "sees" the request directly.
Agent's role: absent
Stage
The AI CEO decomposes the task into subtasks and assigns executors across departments. The agent receives a subtask with context and an autonomy grade.
Agent's role: accept the assignment, verify data completeness
Stage
The agent performs the work and keeps a trace of every action. If another department is needed, the artifact is handed over — nobody imitates a colleague's work.
Agent's role: execute, trace, escalate on missing data
Stage
The result is checked by someone other than the executor, against the criteria from the assignment. An agent cannot accept its own work — that is a rule of the architecture.
Agent's role: provide artifact and trace, fix findings
Stage
The AI CEO folds department results into one answer: what was done, what was not and why, which decisions need a human. The agent contributes its part.
Agent's role: summary for its area, honest status
04 · Boundaries
Autonomy without boundaries is not an agent — it is a liability. Below are hard constraints baked into the architecture, not preferences anyone can toggle off. They are the same for all departments and no autonomy grade removes them.
Review is always a separate role. Otherwise the "accepted without rework" metric becomes meaningless, and a plausible but wrong result reaches the owner as finished.
Payment, publishing on behalf of the company, deleting data, sending mail outside — always with human confirmation. The agent prepares and escalates, but does not press the button.
Missing data stops the task and turns into an escalation describing exactly what was missing. The owner sees a question — not a confidently generated guess.
Every action is written into the trace: what, on which data, with which tool. "The agent did it and did not say" is not a normal situation — it is a contract violation.
Each task has a level: from "draft for review only" to "execute and report". Trying to do more is an escalation, not a silent expansion of rights.
If the task needs a neighboring department's competence, the artifact is handed there instead of being "painted over" on the spot. Departments exchange artifacts, never impersonations.
05 · Comparison
"Agent" is a word used for anything. Here are concrete traits that separate an agent from plain automation and from a bot. None of these traits exists in VOIR yet: the table describes target architecture, not the current state of the product.
| Trait | Script / automation | Chatbot | VOIR AI agent (target) | Human |
|---|---|---|---|---|
| Holds the task goal | no — one step only | no — one dialog only | yes — goal and criteria | yes |
| Plans its own steps | no — rigid scenario | partially — via prompt | yes — plan before work | yes |
| Keeps an action trace | logs, but meaningless | no | yes — what, on what, with what | depends on discipline |
| Passes independent review | no | no | yes — separate role | yes — a manager |
| Escalates missing data | crashes or lies | makes it up | yes — question to the owner | yes |
| Works 24/7 without fatigue | yes | yes | yes | no |
| Bears legal responsibility | no | no | no — the owner only | yes |
The table scrolls horizontally inside its frame — the page itself never widens.
06 · FAQ
No. None of the five pipeline stations is implemented: there is no agent code, no planner, no reviewer. Everything described on this page is target architecture, and every section carries the corresponding badge. What actually runs is this website and the project documentation.
A bot answers a message within a single conversation and bears no responsibility for an outcome. An agent accepts a task with readiness criteria, plans its own steps, executes them while recording a trace, passes independent review, and returns a verifiable artifact. The key difference is not a smarter model — it is an accountability loop: plan, trace, review by someone other than the executor.
It is a check of the result by a separate role that did not do the work. An agent cannot accept its own artifact — otherwise the "accepted without rework" metric becomes meaningless, and a plausible-looking but wrong result reaches the owner as finished. The review compares the artifact against criteria fixed during planning, before any work started.
No, and that is an architectural constraint, not a default setting. Payments, publishing on behalf of the company, deleting data, and irreversible external actions always require human confirmation. The agent prepares everything and escalates the decision to the owner, but it does not press the button itself.
An agent does not take tasks directly from the owner. The owner states the task to the AI CEO, which decomposes it into subtasks and assigns executors across departments. The agent receives a subtask with context and an autonomy grade, returns an artifact and a trace, and the AI CEO folds all department results into one answer for the owner. The full cycle is described on the AI CEO page.
Nobody. The eight departments and the roles that populate them are described on the AI employees page — and all eight are also target architecture. Right now the page, the site and the documentation are made by a human; agents will appear once at least one of the four layers is implemented.
07 · Next
The agent pipeline is part of a bigger picture. Three links that continue the thread: who manages the agents, who staffs them, and what it will cost the owner.
The control center that states the task, distributes subtasks across departments, and folds the report. The agent pipeline plugs in exactly here.
Open →Eight positions that staff the departments: roles, skills, target KPIs and the boundaries of each. An agent is how a position works.
Open →What access to the pipeline will cost once it is implemented. Sales have not started — that page describes a model, not a price list.
Open →