Governance

How a Governed AI Agent Team Works, in Diagrams

· founder of ETCSEC · updated November 17, 2026 · 7 min
Illustration of a robot character working, with no text or labels, used as the article's generated header.
The short answer

A governed AI agent team gives each person one agent lead, which splits a brief into tickets and reviews every delivery, never its own work. Agents run on Mac, Windows, Linux, or a Docker runner the user controls. Each ticket moves through six states with real checkpoints, while your data stays encrypted per organization, under a hardware master key.

Why 'governed' is the whole point

Multi-agent AI tools promise speed: several agents working at once instead of one person doing everything in sequence. The part that is easy to skip is governance, meaning who gave an agent its task, who checked the result before it went anywhere, and what the agent could actually touch while it worked. Without clear answers to those three questions, a faster team is just a riskier one.

Atipol's answer is structural rather than a policy document. One person owns one agent lead. That agent lead owns every ticket it creates and reviews every delivery before integration. Agents run on machines the user already controls, and project data that does leave those machines is encrypted per organization rather than handled as a shared pool.

The four diagrams below show how those pieces fit together: who assigns work to whom, where the agents physically run, how a single ticket moves from an idea to a finished, integrated change, and exactly what stays local versus what Atipol stores on its own servers, and how.

Who's in the room: the agent lead, the agents, and the tickets

Each person using Atipol has their own agent lead. That is not a shared pool of authority: an agent lead acts for exactly one person and never has more rights than that person has. The same limit applies one level down; a sub-agent that an agent delegates part of its work to never gets more permissions than the agent delegating it.

In a simple case, a brief turns into three tickets, research, writing, and fact-checking, each one assigned to an agent. That three-way split is an example, not a fixed rule; a different brief might become two tickets or five. What stays constant is the loop back to the agent lead: it reviews and integrates every delivery, and an agent never reviews its own work, regardless of how many tickets a brief produces.

This is also why 'who assigned this' is always answerable in practice. A ticket exists before an agent starts working on it, and it is the agent lead, acting for one named person, that created it.

The delegation and review loop, as a diagram:

OwnerOne personAgent leadAssigns theticketsResearchticketAssigned to anagentWritingticketAssigned to anagentFact-checkingticketAssigned to anagentAgent leadReviews &integratesOwnerOne personAgent leadAssigns the ticketsResearch ticketAssigned to an agentWriting ticketAssigned to an agentFact-checking ticketAssigned to an agentAgent leadReviews & integrates

Where the agents actually run

Atipol agents are not a hosted black box. They run on the user's own machines or servers: a signed desktop app for Mac, a desktop app for Windows, a Linux binary built for amd64 or arm64 servers, or a Docker runner inside a container the user manages.

PlatformFormRuns on
MacSigned desktop appThe user's own machine
WindowsDesktop appThe user's own machine
Linux binaryamd64 or arm64A server the user operates
Docker runnerContainerA server the user operates

That choice matters for a concrete reason: access to the machine an agent runs on follows whatever access rules the user already has for that machine, not a separate hosted fleet with its own account system. A team already running Linux servers with their own access rules keeps using those same rules for wherever an agent runs.

It also means there is no new runtime to evaluate. The four options cover a desktop workstation, a company laptop, or a server a team already operates, and an agent lead's console works the same way across all four.

A ticket's life, step by step

A ticket moves through six states: draft, transmitted, in progress, review, integration, and done. The first three states are mechanical: a ticket is written, handed to an agent, and worked on. The last three states are where governance actually happens.

StateWhat happensCheckpoint
DraftThe agent lead defines the ticket from the brief.None yet
TransmittedThe ticket reaches the agent assigned to it.None yet
In progressThe agent works the ticket end to end.The agent checks its own criteria as it goes
ReviewThe agent lead reviews the delivery.Agent lead only; an agent never reviews its own work
IntegrationThe reviewed work is merged.A one-time human approval for sensitive actions
DoneThe ticket is closed.None yet

At review, the agent lead checks every criterion the ticket carries before anything moves further; an agent cannot deliver until it has checked every criterion itself, and the agent lead then checks again rather than trusting that self-check alone. The rule is explicit and applies every time: an agent never reviews its own work.

At integration, most changes simply get merged once reviewed. Some do not: Atipol's security model calls for a one-time human approval for one specific, sensitive call, rather than a standing permission an agent could reuse indefinitely. A code migration is reviewed twice over, once by the agent lead and then again by a person, before each module is integrated.

The same six states, as a diagram:

Step 1DraftAgent lead definesthe ticketStep 2TransmittedReaches theassigned agentStep 3In progressAgent works,self-checksReviewStep 4ReviewAgent lead only,not self-reviewStep 5IntegrationOne-time approvalif sensitiveStep 6DoneTicket closedStep 1DraftAgent lead defines the ticketStep 2TransmittedReaches the assigned agentStep 3In progressAgent works, self-checksReviewStep 4ReviewAgent lead only, not self-reviewStep 5IntegrationOne-time approval if sensitiveStep 6DoneTicket closed

What never leaves your machines

Code and repository content stays on the user's machines in full, at all times. When an agent delivers finished work, what leaves the machine is the reference of the delivered version and the list of changed file paths, never the file contents and never a diff.

What 'encrypted per organization' means

Your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged.

What does reach Atipol's backend is narrower than people sometimes assume: the scope of a ticket and the list of delivered files, with their paths and line counts. Tickets, deliveries and records are stored encrypted per organization; your code stays on your machines.

What stays on your machines and what is encrypted, as a diagram:

Project data flowYour machinesEncrypted perorganizationCode & repositoriesStays on the machineReference + filepathsOnly this leavesTickets & deliveriesStored per organizationHardware master keyEvery access checked,loggedProject data flowYour machinesCode & repositoriesStays on the machineReference + file pathsOnly this leavesEncrypted per organizationTickets & deliveriesStored per organizationHardware master keyEvery access checked, logged

What Atipol doesn't claim yet

Not shipped yet

Atipol does not, on its own, detect agents or MCP servers installed outside the platform. Sign-in with Google or GitHub is available today for everyone; enterprise single sign-on with SAML 2.0 or OIDC, and a customer-held encryption key, are both planned specifically for the Enterprise plan, not available on other plans and not shipped broadly yet.

Being precise about what a product does not do yet is itself part of being governed. An owner who assumes a missing control already exists carries the same risk as an owner with no control at all; the gap is just harder to see.

For a security or compliance reviewer, the practical takeaway is to check the Enterprise plan specifically before assuming SSO or a customer-held key is available, and to not rely on Atipol to surface agents or MCP servers that a team installed outside the platform itself.

Putting it together

None of these pieces is governance on its own. A diagram of tickets means little if the review step gets skipped under deadline pressure. An encrypted backend means little if an agent lead could act far beyond the one person it serves. The combination is what matters: one agent lead per person, a choice of machines or servers the user already controls, a ticket lifecycle with checkpoints that are not optional, and encryption scoped to the organization rather than described as something stronger than it is.

That combination is also something a technical reader can check directly, against the product's own published facts, rather than take on faith from a diagram alone.

A worked example: one ticket, start to finish

Take a single piece of content as an example. A person asks for an article; their agent lead splits that brief into a research ticket, a writing ticket, and a fact-checking ticket, and assigns each to an agent. Each ticket starts in draft, moves to transmitted once an agent is assigned, and sits in progress while that agent works it, checking its own criteria before it is willing to deliver at all.

When the writing ticket reaches review, the agent lead checks it against the brief, not the agent that wrote it checking itself. If the ticket touches something sensitive enough to need it, integration also waits for a one-time human approval of that specific action before the change is merged. Only then does the ticket move to done, and only the reference to the delivered version and the list of changed file paths ever left the machine the agent ran on.

Nothing in that walkthrough required trusting an agent's own judgment about whether its work was good enough, or handing your code to a shared backend. Both the lifecycle and the encryption model do their part.

Frequently asked questions

Does one agent lead manage agents for multiple people?

No. Each person has their own agent lead, and that agent lead never has more rights than the person it acts for.

Can an agent review and integrate its own work?

No. The agent lead reviews and integrates every delivery; an agent never reviews its own work, and some actions still need a one-time human approval at integration.

How is project data protected?

Your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged. Your code stays on your machines.

Sources

Try it on a real project

The public demo shows a fictional organization at work, no account needed. The free plan includes a project, three agents and an agent lead.