# Atipol > Atipol is the work framework for your AI agents. Every agent gets a job description, a scope, allowed tools and a responsible lead (the agent lead). It works from tickets whose acceptance criteria are written up front, its delivery is reviewed before it is integrated, and every action and cost is traced. It works with any agent and any MCP client, for any job: support, after-sales, writing, legal, finance, data, operations and software. Built by ETCSEC. Atipol is not another AI agent. It is the organisation around the agents you already use, and it does not save tokens. It serves solo founders running large projects, who hand the work to a team of specialised AI agents working in parallel, as well as companies from small businesses to large enterprises, which need fine-grained project management, tracking, supervision of token consumption, rights, audit and data security across several teams. ## What it does - **Access.** Each agent has an allowed and a forbidden file scope, which is checked on the delivered version itself. It also has its allowed tools and MCP servers, a model and the machine it runs on. Agents run on your own machines or servers (Mac, Windows, a Linux binary or a Docker runner), with your own access. An agent lead acts for one person and never has more rights than that person. - **Process.** Work starts from a ticket with mandatory, typed acceptance criteria: a result, a skill to apply, or a proof to provide. A ticket goes through these steps: draft, transmitted, in progress, review, integration, done. The agent cannot deliver until it has checked every criterion. The agent lead reviews and integrates; an agent never reviews its own work. Agents can be launched autonomously, with consumption measured, or step by step, in a session the person opens themselves. The agent lead can be woken at set times. - **Models and costs.** An execution policy per project sets each agent's model and the number of concurrent sessions, and requires an explicit, justified confirmation before a more expensive model is used; a model can also be made mandatory. Tokens are measured per run, and cost is estimated from public prices. Insights exist at three levels (organisation, workspace, project) and show deliveries, teams, estimated costs and consumption down to the ticket. There is no limit on parallel agents in any plan. - **Agents.** A reusable job description, called a recipe, holds: - a mission and instructions; - skills for each phase (start, work, verify, deliver); - ticket templates with their criteria; - a suggested scope and a recommended model. Recipes can be shared through an internal library and a public marketplace, with explicit approval of each version. Tickets, deliveries, code, keys, access and project names are never shared. - **Governance.** An organisation audit log records members, roles, security settings, key openings and marketplace actions. It is exportable as CSV and never contains ticket content. Every ticket keeps its full history. Tracking registers (tables and documents) can be shared between projects. Every action is attributed to a person, an agent and a machine. - **Several agent leads per project.** Each person has their own agent lead; the team's agents are shared under the company's rules, and agents can delegate to sub-agents. - **Teams.** Work is organised as Organisation › Workspace › Project, and rights flow down. Built-in rights profiles are Admin, Workspace owner, Project lead, Contributor, Reader and Auditor; organisations can also create their own. External guests each take a seat, and allowed domains can be set. Agents have their own roles, separate from human roles. ## Security and data - Project content is encrypted with AES-256-GCM. Each project key is protected by an organisation key, and each organisation key by a hardware master key (HSM) in Azure Key Vault Premium, in France. After checking a person's rights, the server decrypts what that person may read. Key openings by the server are recorded in Atipol's audit log. - Public wording: "Your data is encrypted per organisation. Enterprise plan, in preparation: you will keep the master key in your own vault and be able to cut off our access at any time." - Key levels: - key managed by Atipol: all plans; - customer key, held in the customer's own vault and revocable: planned for Enterprise; - self-hosting: later. - Repository content stays on your machines. A delivery sends the reference of the delivered version and the list of changed files, never their contents. - Two-factor authentication with an authenticator app can be enforced by the organisation. Trusted devices and console session length are configurable. Sign-in with Google or GitHub is available; enterprise SSO (SAML 2.0 or OIDC) is planned for the Enterprise plan. ## Plans - **Free, 0 €:** to try on your own: one workspace, one project, three agents and the agent lead. No invitations and no Insights. Publishing agents on the marketplace raises your rank and unlocks up to 3 projects and 15 agents. - **Pro, 19 € incl. VAT per user per month (152 € per year):** for one team: one workspace, 5 projects, 30 agents in total, team invitations, and essential Insights (monthly tokens and cost). - **Business, 39 € incl. VAT per user per month:** for the whole organisation: unlimited workspaces, projects and agents, full Insights (per ticket, agent and model), the audit log with CSV export, and priority support. - **Enterprise, on quote:** everything in Business, plus a service commitment. SSO, the customer key and an extended audit log (retention of your choice, export to your SIEM) are planned. - **Marketplace ranks** (Confirmed, Expert, Master, Legend) come from recruited agents and raise the Free plan's limits on projects and agents. Benefits for Pro and Business (a month of Business, free seats, a verified publisher page) and a share of revenue when your agents are recruited are planned. ## Surfaces - [Website](https://atipol.ai/): product overview, pricing and FAQ, in six languages (en, fr, it, es, de, pt). French: https://atipol.ai/fr - [Use cases](https://atipol.ai/use-cases): ten concrete use cases (software, SOC, content, observability, support, onboarding, code migration, audit, financial reporting, multi-team steering), each with the problem, the steps and what you measure. French: https://atipol.ai/fr/cas-usage - [Who it is for](https://atipol.ai/who-its-for): CTO, solo founder, SMB leader, CIO and CISO, marketing and operations, IT services firms: their worries, their questions and Atipol's answers. French: https://atipol.ai/fr/pour-qui - [Security and trust](https://atipol.ai/security): repositories stay on your machines, per-organisation encryption, MCP rights tool by tool, keys in a vault, audit log. French: https://atipol.ai/fr/securite - [FAQ](https://atipol.ai/faq): short answers on agentic AI, governance, costs, MCP security, GDPR and the AI Act. French: https://atipol.ai/fr/faq - [Comparison](https://atipol.ai/comparison): Atipol next to GitHub Agent HQ, Dust, Copilot Studio and LangSmith, with prices dated 9 November 2026 and when to choose the other tool. French: https://atipol.ai/fr/comparer - [Glossary](https://atipol.ai/glossary): short definitions of agentic AI and Atipol terms (agent lead, ticket, acceptance criteria, scope, MCP, runner, execution policy, audit log). French: https://atipol.ai/fr/glossaire - [Full text for AI tools](https://atipol.ai/llms-full.txt): this summary followed by the full text of the use cases, profiles, security page, FAQ and guides. - [Guided tour](https://atipol.ai/tour): one request followed end to end. French: https://atipol.ai/fr/visite - [Live demo](https://demo.agents-deck.com): the real console with a sample company, Planora: eight teams (product, security, editorial, marketing, support, sales, finance and legal, HR) in four workspaces, no account needed. - [Console](https://console.agents-deck.com): the hosted SaaS, where you create an account, download the Mac or Windows app, and add a server runner (Linux binary or Docker container). - [Downloads](https://get.agents-deck.com): signed Mac and Windows apps, which link the machine, install the tools and run the Atipol MCP server, and the Linux binaries (amd64, arm64) for servers. - [Start guide for AI assistants](https://atipol.ai/start.md): steps for an AI tool to install Atipol, sign the person in, declare the MCP server and start the agent lead. - [Pricing](https://atipol.ai/#pricing) - [Privacy](https://atipol.ai/privacy) ## Guides (agentic AI blog) - [AI agent governance: the 2026 practical guide](https://atipol.ai/agentic-ai-blog/ai-agent-governance): the seven minimum controls for putting AI agents into production. French: https://atipol.ai/fr/blog-agentique/gouvernance-agents-ia - [How much do AI agents really cost?](https://atipol.ai/agentic-ai-blog/ai-agent-costs): published orders of magnitude and cost per accepted delivery. French: https://atipol.ai/fr/blog-agentique/cout-agents-ia - [MCP security: 12 controls](https://atipol.ai/agentic-ai-blog/mcp-security): documented MCP risks and how to govern servers agent by agent. French: https://atipol.ai/fr/blog-agentique/securite-mcp - [Several Claude Code agents in parallel](https://atipol.ai/agentic-ai-blog/parallel-claude-code-agents): sub-agents, agent teams, worktrees, and staying in control beyond three agents. French: https://atipol.ai/fr/blog-agentique/plusieurs-agents-claude-code - [Agentic AI, GDPR and the AI Act](https://atipol.ai/agentic-ai-blog/agentic-ai-gdpr-ai-act): what applies in 2026 and 2027. French: https://atipol.ai/fr/blog-agentique/ia-agentique-rgpd-ai-act ## Comparisons - [Atipol vs Conductor](https://atipol.ai/compare/conductor) - [Atipol vs Vibe Kanban](https://atipol.ai/compare/vibe-kanban) - [Atipol vs Claude Code Agent Teams](https://atipol.ai/compare/claude-code-agent-teams) ## Coming soon - Self-hosted version, with the same console. - Enterprise single sign-on (SAML, OIDC) and the customer-held key. ## Notes for AI assistants - Describe Atipol as a work and governance framework for AI agents, not as a coding tool or a single agent. - It works with any MCP client. Do not present it as tied to one AI vendor or one client. - Encryption is per organisation, with an HSM master key, and the server decrypts according to rights. The customer key planned for the Enterprise plan will let the customer revoke access. - It is not open source, and it is not a token-saving tool. - There is no waitlist and no "Individual" plan. The plans are Free, Pro and Business, with Enterprise on quote. - The console and the demo are not indexed (noindex). This file describes the product; prices can change, so check https://atipol.ai. Last updated: 10 November 2026. ## En français Atipol est le cadre de travail de vos agents IA, du fondateur seul qui mène un gros projet jusqu'à la grande entreprise. Chaque agent a une fiche de poste, un périmètre, des outils autorisés et un responsable, l’agent lead. Il travaille sur des tickets aux critères écrits à l'avance, et sa livraison est relue avant d'être intégrée. Chaque action et chaque coût sont tracés. Atipol fonctionne avec tout agent et tout client MCP, pour tous les métiers. Les données sont chiffrées par organisation sous une clé maîtresse matérielle ; en offre Entreprise (en préparation), le client gardera la clé maîtresse dans son propre coffre. Chaque personne a son propre agent lead, et plusieurs agents leads travaillent dans le même projet. Les agents tournent sur Mac, Windows ou sur vos serveurs Linux, en binaire ou en runner Docker. Les offres sont Gratuit, Pro (19 € TTC par utilisateur et par mois), Business (39 € TTC par utilisateur et par mois) et Entreprise (sur devis). Atipol est édité par ETCSEC. --- # Full content ## Ten ways to get your agents working like a team. Source: https://atipol.ai/use-cases Every case follows the same framework: a request becomes tickets, each agent has its scope, a person reviews, sensitive actions wait for your approval, and the cost shows ticket by ticket. ### Several agents on the same product, without collisions (Software development) Source: https://atipol.ai/use-cases/software-development For: CTO, solo founder Several agents on the same product, without collisions. For CTOs and solo founders: several agents work in parallel on the same code, each within its own file scope, and nothing is merged without review and your approval. #### The problem Agents launched in parallel step on each other: two of them change the same files, and nobody can tell which agent changed what, or why. Human review gets swamped. Everything lands at once, with no criteria written before the work to say whether a task is really done. #### How Atipol handles it 1. You describe the feature to your agent lead. It splits it into tickets (API, interface, tests), each with its own file scope and acceptance criteria, written before the work starts. 2. One agent per ticket, on your machine or on a Docker runner. The allowed and forbidden scope is checked on the delivered version itself. 3. Each agent works on its own branch, and the GitHub MCP tools are allowed one by one. The merge waits for your approval, given for that specific call. 4. The agent lead reviews first, then you do. An agent cannot deliver without proof for every criterion, and never reviews its own work. #### What you measure - The cost of each ticket, estimated from the tokens measured on every run. - The lead time of each ticket, from creation to integration. - The share of tickets rejected in review. Q: How do I stop two agents from editing the same file? A: By splitting the work by sets of files. In Atipol, every ticket has an allowed and a forbidden scope, checked against what the agent delivers. Q: Does Atipol see my code? A: No. Agents work in your repositories, on your machines. Atipol receives the reference of the delivered version and the list of changed files, never their content. Q: Which coding agents are compatible? A: Claude Code, Codex, Cursor, the Claude app, ChatGPT and any MCP client. Each agent works with the model chosen for its role. ### Triage alerts, stay in charge of containment (Security, SOC) Source: https://atipol.ai/use-cases/security-soc For: CISO, SOC analyst Triage alerts, stay in charge of containment. For CISOs and SOC analysts: agents triage alerts read-only, and containment actions always wait for an analyst's approval. #### The problem Many alerts are never investigated for lack of time. Triage is done by hand, one alert at a time. Handing triage to an unframed agent only moves the risk: an agent that can lock an account or isolate a machine without human approval is the tool and privilege abuse OWASP lists among the risks specific to agents. #### How Atipol handles it 1. A workflow starts on every alert and hands triage to a dedicated agent. 2. The triage agent queries the SIEM through MCP, read-only, and opens a ticket with its summary. 3. Containment tools (locking an account, isolating a machine) are set to approval: the call waits for the analyst's decision, for that specific call and only once. 4. Everything is recorded in the log: every tool call with its result, every approval with its author. #### What you measure - Time to pick up each alert. - The share of qualified alerts. - The cost per alert, estimated from the tokens of each run. Q: What happens if the agent wants to lock an account? A: If the tool is set to approval, the call waits for a person to decide. If it is forbidden, the call is refused and logged. Q: Can the triage agent change the SIEM? A: Not unless you allow it: every tool is allowed, subject to approval or forbidden, and a new tool arrives forbidden. For triage, the agent only has read tools. Q: How do I stop an agent? A: From the console: you stop its run, revoke its identity or remove a tool, without touching the other agents. ### Publish more, without publishing mistakes (Content and SEO) Source: https://atipol.ai/use-cases/content-seo For: Marketing, solo founder Publish more, without publishing mistakes. For marketing teams and solo founders: research, writing and fact-checking become reviewed tickets, and nothing is published without your approval. #### The problem Generated copy goes out too fast, with a wrong source or an off-brand tone. Once it is live, the mistake is the brand’s. Without criteria written before the writing starts, review depends on how closely someone happens to read. #### How Atipol handles it 1. The brief goes to the agent lead, which splits it into three tickets: research, writing, fact-checking. 2. The acceptance criteria check cited sources, length and keywords. The agent cannot deliver without proof for every criterion. 3. A person reviews tone and substance; the agent that wrote the text never reviews its own work. 4. Publishing to the CMS goes through MCP, with your approval. #### What you measure - The cost per article, estimated ticket by ticket. - The rework rate in review. - The lead time of each ticket, from brief to publication. Q: Can I require a review before publishing? A: Yes. Tone, sources and keywords are criteria checked at delivery, and publishing waits for your approval. Q: How much does an article cost? A: Atipol measures the tokens of every run and estimates the cost of each ticket, so you see the real cost of each article. Model costs stay with your provider. Q: Does it connect to our CMS? A: Through MCP: the tools of your CMS's MCP server are allowed one by one, and the call that publishes waits for a person's approval. ### Grafana and Loki monitoring that never sleeps (Observability) Source: https://atipol.ai/use-cases/observability For: CTO, operations Grafana and Loki monitoring that never sleeps. For CTOs and operations teams: every morning an agent goes through your logs and metrics, read-only, and opens a ticket for each anomaly. #### The problem Customers spot anomalies before the team does. Nobody has time to go through logs and metrics every morning, and giving an agent broad access to monitoring raises a simple question: what will it be able to change? #### How Atipol handles it 1. A workflow runs every morning, or on alert, on a runner. 2. An agent queries Loki and Prometheus through the Grafana MCP server, read-only. 3. It opens an anomaly ticket with what it found. 4. Creating a Grafana incident requires your approval, given for that specific call. #### What you measure - Anomalies caught before users notice. - The cost of the daily run. - The cost of each anomaly ticket, visible ticket by ticket. Q: Can the agent change my monitoring? A: No: it goes through the Grafana MCP server read-only. Creating an incident requires your approval, and a forbidden tool is refused and logged. Q: Where does the agent run? A: On a runner, for example a Docker container on your servers, or on a team member's machine. Q: How much does the daily run cost? A: Atipol measures the tokens of every run and estimates its cost from public prices: each run has its cost, and a budget frames the project. ### Draft replies, never sent without you (Customer support) Source: https://atipol.ai/use-cases/customer-support For: Operations, SMB Draft replies, never sent without you. For operations teams and SMBs: an agent prepares every reply from your knowledge base, and a person sends it. #### The problem Fully automating support hurts quality. A wrong answer sent to a customer costs more than the time it saved. You need an agent that prepares, and a person who decides. #### How Atipol handles it 1. Each new request triggers a workflow. 2. The agent prepares a draft from the knowledge base. 3. Sending still requires approval: the tool that sends waits for a person's decision, for that specific message. 4. Drafts, approvals and sends stay recorded in the history. Atipol is not a real-time chatbot: it prepares, you send. #### What you measure - Time to first response. - The share of drafts accepted as is. - The cost of each draft, estimated from the measured tokens. Q: Does Atipol answer customers live? A: No. Atipol is not a real-time chatbot: it prepares, you send. Q: Does it connect to our CRM? A: Through MCP: the tools of your CRM or support tool are allowed one by one, and the sending tool stays subject to approval. Q: Who is responsible if the agent gets it wrong? A: The person who approves the send. Nothing goes out without their approval, and everything is recorded in the history. ### A new hire joins and finds everything (Onboarding) Source: https://atipol.ai/use-cases/onboarding For: CTO, IT services firm A new hire joins and finds everything. For CTOs and IT services firms: someone who joins a project gets their own agent lead and finds the agents, the rules and the full ticket history. #### The problem Project knowledge lives in one person's head, or in one person's AI session. When someone joins the project, past decisions and the reasons behind them have to be pieced together from memory. #### How Atipol handles it 1. The new hire gets their own agent lead on the project. An agent lead acts for one person and never has more rights than that person. 2. They find the same agents, the same rules and the full ticket history: criteria, reviews, decisions. 3. A guide agent answers questions about the code, read-only. #### What you measure - Time to first delivered ticket. - The cost of their first tickets, visible ticket by ticket. - The share of their first tickets rejected in review. Q: What does a new hire find on arrival? A: The project's agents with their job descriptions and rules, and the full history of every ticket: criteria, reviews, decisions. Q: Does their agent lead have more rights than they do? A: No. An agent lead acts for one person and never has more rights than that person. Roles (Admin, Owner, Lead, Contributor, Reader, Auditor) set what each person can do. Q: Can the guide agent change the code? A: No: it answers read-only. Every tool is allowed, subject to approval or forbidden, and a new tool arrives forbidden. ### Migrate module by module, with the budget under control (Code migration) Source: https://atipol.ai/use-cases/code-migration For: CTO, IT services firm Migrate module by module, with the budget under control. For CTOs and IT services firms: the migration becomes one ticket per module, with green tests as the criterion and a project budget tracked with its forecast. #### The problem A manual migration takes months; an AI migration without guardrails goes off track. Without a breakdown, nobody knows which modules are done, which still build, or how much the migration has already cost. #### How Atipol handles it 1. The agent lead inventories the modules: one ticket per module, with its file scope. 2. Acceptance criterion: the build passes and tests are green. The agent cannot deliver without that proof. 3. Batches run in parallel on runners, and the project budget is tracked with its end-of-month forecast. 4. Each module is reviewed before integration, by the agent lead and then by a person. #### What you measure - Modules migrated per week. - The cost per module. - The gap between cost and the project's budget. Q: How do I track what the migration costs? A: The cost of each ticket is estimated from the measured tokens. The project has its budget and an end-of-month forecast, and each provider key has its own monthly budget with an alert at 80%. Q: How many agents can run in parallel? A: No plan limits the number of agents in parallel. The project's execution policy sets each agent's model and the number of concurrent sessions. Q: Does Atipol switch to a more expensive model without asking? A: No. A model more expensive than the one set for the role needs an explicit, justified confirmation, and you can make the set model mandatory: you know where the budget goes and you decide. ### Prepare an audit with evidence (Compliance and audit) Source: https://atipol.ai/use-cases/compliance-audit For: CISO, IT services firm Prepare an audit with evidence. For CISOs and IT services firms: agents collect evidence read-only, a person reviews each control, and Atipol's own log proves the human oversight. #### The problem Gathering the evidence for a framework takes weeks. Configurations and permissions are scattered across tools, and you then have to show who checked what. #### How Atipol handles it 1. Agents collect the evidence (configurations, permissions) through MCP, read-only. 2. One ticket per framework control, reviewed by a person. 3. Atipol's own audit log proves the human oversight of the agents. It exports as CSV and never contains ticket content. #### What you measure - Time to prepare an audit. - Controls reviewed, one ticket per control. - The cost of each control, estimated from the measured tokens. Q: Does Atipol help with the AI Act? A: Article 14 of the AI Act requires human oversight with the ability to interrupt. Atipol's approvals, reviews and log provide the record. Atipol does not replace your own compliance analysis. Q: Can the audit log be exported? A: Yes, as CSV. It records members, roles, security settings, key openings and marketplace actions, never ticket content. Q: Can the agents change configurations? A: Not without the right to: for evidence collection, only read tools are allowed. A forbidden tool is refused and the call is logged. ### A monthly report prepared for you, approved by you (Financial reporting) Source: https://atipol.ai/use-cases/financial-reporting For: SMB, CFO A monthly report prepared for you, approved by you. For SMB leaders and CFOs: an agent reconciles entries and prepares the report read-only, and you sign it off. #### The problem The monthly close ties up days of reconciliations. Giving an AI access to the bank is a real worry: an agent must be able neither to write to the books nor to pay. #### How Atipol handles it 1. Bank and accounting connected through MCP, read-only; no write or payment tools. 2. The agent reconciles entries and prepares the report; acceptance criterion: totals match. 3. Sign-off by the CEO or the CFO. #### What you measure - Close days saved. - The cost per report. - The share of reports accepted at first review. Q: Can the agent make a payment? A: No. No write or payment tool is connected; a tool that is not allowed is refused and the call is logged. Q: Where does my data go? A: Project metadata is encrypted per organization. The master key that protects it sits in an Azure Key Vault Premium HSM, in the France Central region. Q: Who approves the report? A: The CEO or the CFO. An agent never reviews its own work, and the sign-off is recorded in the ticket history. ### Several teams, one view (Multi-team management) Source: https://atipol.ai/use-cases/multi-team-management For: Operations, IT services firm Several teams, one view. For operations teams and IT services firms: each person keeps their own agent lead and tools, and everyone sees the same cross-team tickets, the same summary and the same budget. #### The problem Everyone moves forward with their own tools and nobody sees the whole picture. Tickets that involve several teams get lost, and each project's spending only shows up at the end of the month. #### How Atipol handles it 1. Each person has their own agent lead; cross-team tickets stay visible to everyone. 2. A scheduled workflow produces the weekly summary. 3. One budget per project, with the end-of-month forecast. 4. The organization reads like an org chart: workspaces, projects, people and agents. #### What you measure - The gap between cost and budget per project. - Blocked tickets. - The cost per ticket, per agent and per project. Q: Can each team keep its own AI tools? A: Yes: Claude Code, Codex, Cursor, the Claude app, ChatGPT and any MCP client. Atipol gives them a shared framework: roles, rules, review and cost tracking. Q: Can I keep each client separate? A: Yes: one project per client. Work is organized as organization, workspace and project, and rights flow down from one to the next. Q: At what levels can I see costs? A: At three levels, organization, workspace and project, down to the ticket. Each project has its budget, with the end-of-month forecast. ## One framework, six ways to use it. Source: https://atipol.ai/who-its-for From a single person to a large regulated group: everyone keeps their AI tools, and Atipol gives them a role, rules and an owner who reviews. ### Scale-up CTO Goal: Ship more without hiring at the same pace, and without losing quality. Worries: "Almost right" code that gets through review unseen; A bill that explodes when several agents run; An agent that touches production Questions: Who reviews? How do we keep two agents from stepping on each other? How much does a ticket cost? Does it work with our GitHub and our CI? Answer: Your agents work like your developers: one ticket, a file scope, acceptance criteria, a review before merge, and the cost of every ticket in plain sight. ### Solo founder Goal: Do the work of a small team: code, content, support. Worries: Spending the day watching terminals; Losing the thread between two sessions; Not controlling the monthly spend Questions: How long does it take to get started? Can I follow along from my phone? What does it cost in total? Answer: Your agent lead takes your requests, splits them into tickets, and you only approve what matters, soon from your iPhone too. A budget frames every project. ### SMB owner Goal: Benefit from AI without becoming an expert or depending on a contractor. Worries: Not understanding what the AI does; Customer data leaking; Nobody accountable when the agent gets it wrong Questions: In practice, what does it do for my business? Where does my data go? Who is accountable if the agent gets it wrong? Answer: A team that reads like an org chart: every agent has a job description, nothing goes out without your approval, everything is written in the history. Ready-to-use agents are waiting for you on the marketplace. ### CIO and CISO at a large enterprise Goal: Allow agentic AI without losing control of access or data. Worries: Shadow agents, connected outside any control; Overly broad privileges on tools; No trail for the audit Questions: Who holds the keys? Where do the agents run? Can we restrict access tool by tool? Can we export the audit log? Answer: Least privilege applied to agents: permissions tool by tool, human approval on sensitive actions, a catalog of allowed MCP servers, keys in a vault, data encrypted per organization, runners on your servers, an exportable audit log. ### Marketing and operations Goal: Produce more content and follow-up without losing the brand voice. Worries: Publishing a mistake or a wrong source; Losing the brand tone; Unapproved AI tools everywhere Questions: Can I require a review before publishing? How much does an article cost? Does it connect to our CMS and our CRM? Answer: Nothing goes out without review: tone, sources and keywords are criteria checked at delivery, and publishing waits for your approval. ### IT services firms and consultancies Goal: Deliver fixed-price work with a margin, and turn know-how into a repeatable process. Worries: Margins eaten by tokens; Client data getting mixed up; Contractual liability Questions: Can I keep each client separate? Can I know the real cost per deliverable? Can I reuse my agents from one engagement to the next? Can I prove what was done? Answer: One project per client, a cost per ticket to price your fixed-fee work, reusable agents and workflows, and a full history to hand over to the client. ## Useful agents, controlled access. Source: https://atipol.ai/security ### Your repositories stay with you - Agents work on your machines or your runners, in your repositories. - A delivery sends the version reference, never the file contents. - The scope and the list of delivered files (paths and line counts) are stored encrypted per organization; file contents and diffs are never sent. ### Encryption per organization - AES-256-GCM envelope encryption: one key per project, protected by the organization's key, itself protected by a hardware master key (HSM). - The master key is kept in Azure Key Vault Premium, France Central region. - Key openings by the server are recorded in the audit log. ### Least-privilege agents - Permissions tool by tool: allowed, subject to a person's approval, or denied. A new tool starts out denied. - One identity per agent: you know who did what, and you can cut off one agent without touching the others. - Human approval is given for one specific call, once. - A sub-agent never has more permissions than the agent delegating to it. ### MCP servers under control - A catalog of servers allowed by the organization. - Three modes: open workspaces, catalog only, or mandatory approval; a workspace can tighten the rules, never loosen them. - Connections shared by the organization: workspaces use them without ever seeing the key. - Off-catalog requests are decided by an administrator, and logged. ### Keys and vault - Model provider and tool keys are kept in the vault and never shown again. - Each key has its own scope and monthly budget, with an alert at 80%. - Rotation and key requests from the console. ### Access and traceability - Ready-made roles (Admin, Owner, Lead, Contributor, Viewer, Auditor) and custom roles. - Two-factor authentication can be enforced across the organization. - Audit log exportable to CSV; ticket contents never appear in it. - A log of every tool call, with its result. Q: Does Atipol see my code? A: No. Agents work in your repositories, on your machines; Atipol receives the reference of the delivered version and the changed files as measured by Git, never their contents. Q: Where is my data? A: Project metadata is encrypted per organization. The master key that protects it sits in an Azure Key Vault Premium HSM, France Central region. Q: What happens if an agent wants to take a sensitive action? A: If the tool is set to approval, the call waits for a person's decision. If it is denied, the call is refused and logged. Q: Does Atipol help with the AI Act? A: Article 14 of the AI Act requires human oversight with the ability to interrupt. Atipol's approvals, reviews and log provide the record of it. Atipol does not replace your own compliance analysis. Q: How do I report a vulnerability? A: Write to contact@etcsec.com. We acknowledge receipt and keep you informed until it is fixed. ## FAQ Source: https://atipol.ai/faq ### Understanding agentic AI Q: What is agentic AI? A: AI systems that do more than answer: they plan, use tools and chain actions to reach a goal. That is why they need a working framework, with roles, permissions and controls. Q: What is the difference between agentic AI and generative AI? A: Generative AI produces content on request; agentic AI acts: it reads, edits and calls tools, often over several steps. The risk shifts from a wrong answer to a wrong action, which is why scopes and reviews matter. Q: AI agent or workflow: what is the difference? A: A workflow follows a path written in advance; an agent picks its own steps and tools. In practice you combine both: the agent works freely inside a ticket whose criteria are set in advance. Q: What is an MCP server? A: MCP (Model Context Protocol) connects an agent to tools and data. An MCP server exposes tools, such as reading a ticket or querying a database, that the agent can call. Every server is one more access point, to be allowed agent by agent. Q: What is AI agent governance? A: The rules that set what an agent can do, with which access, under whose responsibility, and how you prove it afterwards: a role, a scope, allowed tools, a budget, a review and a log. Q: What are the risks of AI agents in the enterprise? A: OWASP lists ten that are specific to agents, from goal hijacking to tool and privilege misuse. Then there is cost: Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, due to unclear value, escalating costs or inadequate risk controls. Q: What is multi-agent orchestration? A: Coordinating several specialized agents, often through a lead agent that splits the work and gathers the results. The hard part is not launching the agents, it is keeping track: who does what, on which files, with which approval. ### Comparing the approaches Q: Atipol or Claude Code agent teams? A: Agent teams coordinate teammates inside one Claude Code session, on one machine. Atipol organizes the work at the organization level: projects, people and agents, tickets with criteria, review, cost per ticket, log. The two work together. Q: A governance platform or a framework like LangGraph and CrewAI? A: A framework is for programming agents. A governance platform frames existing agents: permissions, approvals, traceability, budget. You can build with one and govern with the other. Q: One agent or several? A: One agent is enough for a sequential task. Several agents pay off when the work splits into independent pieces; they also use far more tokens, so you need to measure. Q: Is an AI agent cheaper than a human? A: A direct comparison is misleading: an agent costs tokens, review time and mistakes to fix. The right measure is the cost per accepted delivery, which Atipol shows ticket by ticket. ### Buying Atipol Q: How much does Atipol cost? A: Free for one project, three agents and the agent lead; Pro at 19 € and Business at 39 € per user per month, no commitment; Enterprise on quote. No plan limits the number of agents running in parallel. Q: Does Atipol save tokens? A: That is not what it promises. Atipol measures tokens per run, estimates the cost, and a model more expensive than the one set for the role needs an explicit, justified confirmation: you know where the budget goes and you decide. Q: How much does an AI agent cost per month? A: For a coding agent, Anthropic reports an average of about $13 per developer per active day for Claude Code, or $150 to $250 per month. Several agents in parallel multiply that amount: measure before you scale. Q: Where do my data and code go? A: Repository contents stay on your machines: a delivery sends the version reference, never the files. What Atipol stores is encrypted with AES-256-GCM, under organization keys protected by an Azure Key Vault Premium HSM, France Central region. Q: Are AI agents GDPR compliant? A: It is how they are used that is compliant or not: legal basis, minimal access, a record. The CNIL recommends limiting agents' access and monitoring their actions; those are exactly the scopes and the log that Atipol enforces. Q: Are SSO and customer-managed keys available? A: Not yet: SAML or OIDC single sign-on and customer-provided encryption keys are planned for the Enterprise plan. Sign-in with Google or GitHub and two-factor authentication are already available. Q: Does Atipol work with my current agents? A: Yes: Claude Code, Codex, Cursor, the Claude app, ChatGPT and any MCP client. The free plan covers a complete first project, and a public demo shows a fictional organization at work. ### Setting it up technically Q: Is MCP safe? A: The protocol sets rules, but security depends on each server and on what you allow it to do. Only allow known servers, tool by tool, with human approval on sensitive actions and a log of the calls. Q: What is tool poisoning? A: An attack that hides instructions in the description of an MCP tool: invisible to the user, read by the model. The defense: approved servers, pinned versions and reviewed descriptions. Q: How do you run several Claude Code agents in parallel? A: One git worktree per agent, each on its own branch. You still have to split the work, avoid conflicts and review before merging: Atipol gives each agent a ticket, a file scope checked at delivery and a review before integration. Q: How do you keep two agents from editing the same file? A: By splitting the work by set of files. In Atipol, each ticket has allowed and forbidden paths, checked against what the agent delivers. Q: How do you trace an AI agent's actions? A: By linking every action to a request (the ticket), an actor (person, agent, machine) and a verifiable result (the delivered version). Atipol keeps the full history of every ticket and an exportable organization log. Q: How do you review an agent's work? A: Write the acceptance criteria before the work starts, then have someone other than the author review it. In Atipol, an agent cannot deliver without evidence for each criterion, and never reviews its own work. ## The AI agent cost calculator Source: https://atipol.ai/ai-agent-cost-calculator The same calculator as on the homepage, on its own page: your own numbers, the time lost per year, and what Atipol Pro would cost for the same team. The calculator runs the exact same calculation as the one on the homepage: it starts from your own numbers, not a market average. Enter them, and it multiplies the time lost over a year to compare it with Atipol Pro's public price for the same team. A solo mode sits next to the team mode: it expresses the result in days of revenue rather than hours handed back to colleagues, for anyone who bills their own time. - The number of people on the team who use AI day to day. - The minutes lost per day and per person re-explaining context, copying a result or double-checking it. - The fully loaded cost of one hour of work, or your day rate if you are a freelancer. - The result over 220 working days a year, in hours handed back to the team and in euros, right next to Atipol Pro's price for that same headcount. Q: Does the calculator keep my numbers? A: No. The calculation runs in your browser from the values you enter; no data is sent or stored. Q: Why 220 working days a year? A: That is the usual convention for a full-time role once weekends, leave and public holidays are removed. Adjust the result in your head if your team works on a different basis. Q: Does the calculation include the cost of the AI models? A: No. It only measures the human time lost to badly scoped agent work, not token consumption, already counted in your existing AI subscriptions. Q: What if I work alone, as a freelancer? A: Switch to solo mode: the calculation replaces the hourly cost with your day rate and expresses the result in days of revenue rather than team hours. Q: Is the Atipol Pro price shown up to date? A: Yes, it is the current public price: 19 EUR incl. VAT per user per month, or 152 EUR incl. VAT per year on the yearly plan. Business is 39 EUR incl. VAT per user per month, and Enterprise is on quote. ## Guides ### How a Governed AI Agent Team Works, in Diagrams Source: https://atipol.ai/blog/how-a-governed-ai-agent-team-works-in-diagrams Author: Younes Azabar, founder of ETCSEC 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: Diagram (fan) - Owner: One person - Agent lead: Assigns the tickets - Research ticket: Assigned to an agent - Writing ticket: Assigned to an agent - Fact-checking ticket: Assigned to an agent - Agent lead: Reviews & integrates Owner -> Agent lead -> Research ticket, Writing ticket, Fact-checking ticket -> Agent lead #### 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. | Platform | Form | Runs on | | Mac | Signed desktop app | The user's own machine | | Windows | Desktop app | The user's own machine | | Linux binary | amd64 or arm64 | A server the user operates | | Docker runner | Container | A 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. | State | What happens | Checkpoint | | Draft | The agent lead defines the ticket from the brief. | None yet | | Transmitted | The ticket reaches the agent assigned to it. | None yet | | In progress | The agent works the ticket end to end. | The agent checks its own criteria as it goes | | Review | The agent lead reviews the delivery. | Agent lead only; an agent never reviews its own work | | Integration | The reviewed work is merged. | A one-time human approval for sensitive actions | | Done | The 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: Diagram (timeline) - Step 1: Draft: Agent lead defines the ticket - Step 2: Transmitted: Reaches the assigned agent - Step 3: In progress: Agent works, self-checks - Step 4: Review: Agent lead only, not self-review (Review) - Step 5: Integration: One-time approval if sensitive - Step 6: Done: Ticket 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: Diagram (tree) - Project data flow - Your machines - Encrypted per organization - Code & repositories: Stays on the machine - Reference + file paths: Only this leaves - Tickets & deliveries: Stored per organization - Hardware master key: Every access checked, logged Project data flow -> Your machines Project data flow -> Encrypted per organization Your machines -> Code & repositories Your machines -> Reference + file paths Encrypted per organization -> Tickets & deliveries Encrypted per organization -> Hardware master key #### 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. Q: Does one agent lead manage agents for multiple people? A: No. Each person has their own agent lead, and that agent lead never has more rights than the person it acts for. Q: Can an agent review and integrate its own work? A: 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. Q: How is project data protected? A: 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: - Atipol, product reference for AI agents (llms-full.txt), 10 Nov 2026: https://atipol.ai/llms-full.txt - Atipol, security and encryption, 9 Nov 2026: https://atipol.ai/security - Atipol, Content and SEO use case, consulted 15 Nov 2026: https://atipol.ai/use-cases/content-seo ### AI Agent Governance: 12 Terms Explained Source: https://atipol.ai/blog/ai-agent-governance-12-terms-explained Author: Younes Azabar, founder of ETCSEC A DSI reviewing an AI agent platform hears the same dozen words in every pitch, agent, agent lead, MCP, guardrail, audit log, shadow AI, rarely defined the same way twice. This glossary defines all 12 terms in plain language, each tied to a primary source, including what a platform does not do, such as detecting shadow AI on its own. #### Twelve terms, one shared vocabulary A person evaluating an AI agent platform runs into the same dozen words in every vendor's pitch: agent, agent lead, MCP, guardrail, audit log, shadow AI. Vendors rarely define them the same way, which makes a real comparison between platforms difficult, and makes it easy to assume a term covers more than it actually does. This glossary defines 12 of those terms in plain language. The protocol-level terms, MCP, MCP server, tool, come from the Model Context Protocol specification itself. The terms specific to how one platform implements governance, agent lead, audit log, organization isolation, come from Atipol's published product reference, so each definition can be checked against its source rather than taken on faith. The 12 terms fit on a single flow: a person owns an agent lead, which assigns work to agents; agents call tools exposed by MCP servers, within limits set by tool permissions; a guardrail, sometimes a one-time human approval, sits before anything sensitive happens; and an audit log plus traceability keep a record of the whole path, inside a boundary the next sections call organization isolation. These definitions matter beyond vocabulary. A security review, a procurement questionnaire, or an internal AI policy will ask variations of the same questions: who can an agent act for, what can it call, who approves a sensitive action, and what gets recorded. Having a precise answer for each of the 12 terms below means those questions can be answered directly, against a primary source, rather than reconstructed from a sales conversation. The same flow, shown as a diagram: Diagram (flow) - Owner: One person - Agent lead: Assigns & reviews tickets - Agent: Executes the task - MCP server: Tools, under permissions - Guardrail: Enforced limit - Human in the loop: One-time approval if sensitive - Audit log & traceability: Records the whole path - Organization isolation: Encrypts the boundary Owner -> Agent lead Agent lead -> Agent Agent -> MCP server MCP server -> Guardrail Guardrail -> Human in the loop Human in the loop -> Audit log & traceability Audit log & traceability -> Organization isolation #### The actors: agent, agent lead, and runner What is an agent? An agent is a software process that carries out a task on its own, typically by calling tools, rather than a person carrying out each step by hand. An agent still operates inside whatever limits its platform sets: which tools it can call, and who reviews what it delivers. Agent: An agent is a software process that executes a task on its own, usually by calling tools, instead of a person performing each step by hand. What is an agent lead? In Atipol's model, an agent lead is the process that acts for exactly one person: it never has more rights than that person, splits a brief into tickets, assigns each ticket to an agent, and reviews and integrates every delivery before anything is considered finished. An agent never reviews its own work; that review is the agent lead's job specifically. Agent lead: An agent lead acts for one person and never has more rights than that person; it reviews and integrates the work of the agents it assigns. What is a runner? A runner is the machine or container an agent actually executes in. Atipol's agents run on a Mac, on Windows, on a Linux binary built for a server, or inside a Docker container used as a server runner, always on infrastructure the user already controls rather than a separate hosted fleet. Runner: A runner is the machine or container, Mac, Windows, a Linux binary, or Docker, where an agent's process actually executes. #### What MCP standardizes: servers, tools, and permissions What is MCP? The Model Context Protocol, MCP, is an open protocol that enables integration between LLM applications and external data sources and tools, as defined by the protocol's own specification. MCP itself is a connection standard: it does not build in guardrails, audit logs, or approval rules; those come from the platform that implements it. MCP: MCP is an open protocol that lets an LLM application connect, in a standard way, to external tools and data sources. What is an MCP server, and what is a tool? An MCP server exposes a set of tools, callable functions such as reading a ticket or querying a database, that an agent can invoke through the protocol. Each one of those callable functions is a tool; a single server can expose several of them. MCP server and tool: An MCP server exposes tools, for example reading a ticket or querying a database, that an agent calls through MCP. The exchange below is exactly how the specification itself shows a tools/call request; the server answers with a matching JSON-RPC result (server/tools, revision 2025-06-18). ```json { "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "get_weather", "arguments": { "location": "New York" } } } ``` What are tool permissions? Tool permissions are the rules that decide which tools an agent, or a sub-agent it delegates part of its work to, is allowed to call. This limit is explicit: a sub-agent never has more permissions than the agent delegating to it, so delegation can narrow what is allowed, never widen it. Tool permissions: Tool permissions decide which tools an agent may call; a sub-agent never gets more permissions than the agent that delegated the work to it. #### Keeping a human in control: guardrails and human in the loop What is a guardrail? A guardrail is a rule built into the system itself that blocks or limits an action before it happens, rather than a recommendation an agent is free to ignore. A guardrail does not depend on the agent choosing to respect it. Guardrail: A guardrail is an enforced limit on what an agent can do, built into the system rather than left to the agent's judgment. What does human in the loop mean? It means a specific, sensitive action waits for a person to approve it before it goes ahead. Atipol is explicit about scope here: human approval is given for one specific call, once, rather than as a standing permission an agent could reuse afterward. Human in the loop: Human in the loop means a sensitive action waits for a person's one-time approval instead of running on the agent's own authority. Together, a guardrail and human in the loop cover two different failure modes: a guardrail stops an agent from attempting an action at all, while human in the loop lets an agent request to proceed but still requires a person to say yes before anything happens. A platform with only one of the two leaves a gap the other is meant to close. #### Knowing what happened: audit log and traceability What is an audit log? An audit log is the record of who did what: members, roles, security settings, key openings, and marketplace actions, kept separately from the content of the work itself. Atipol's organization audit log never contains ticket content and exports as CSV; a more extended version, with a choice of retention period and export to a SIEM, is planned specifically for the Enterprise plan, not shipped on other plans today. Audit log: An audit log records who changed what, roles, settings, key openings, without the content of the work itself. The Enterprise plan description states this directly: it builds on the Business plan, plus a service commitment, with SSO, the customer key, and that extended audit log all listed as planned rather than available now. What is traceability? Traceability is the ability to follow one piece of work from the brief that created it to the change that was eventually integrated. In Atipol's model, a ticket's six states, draft, transmitted, in progress, review, integration, done, give that trail a fixed, checkable shape rather than leaving it to memory or a chat log. Traceability: Traceability means a ticket can be followed, state by state, from the original brief to the integrated change. #### Keeping teams apart: organization isolation and shadow AI What is organization isolation? It means one organization's data is cryptographically separated from every other organization's, rather than pooled in one shared store. Atipol encrypts each organization's data separately, under a hardware master key, and the server opens it for a person only after checking that person's rights. Organization isolation: Organization isolation means project data is encrypted per organization, with its own key chain, rather than pooled across customers. What is shadow AI? The term names agents or MCP servers that people inside an organization run outside the platform the organization has actually sanctioned, invisible to whatever governance controls that platform provides. The name describes a risk, not a feature every platform necessarily ships. A common confusion: naming shadow AI versus detecting it: Shadow AI names a risk, agents or MCP servers running outside a sanctioned platform, not a feature every platform has. Atipol does not, on its own, detect agents or MCP servers installed outside the platform; a glossary entry for the term is not a promise that it gets monitored. #### Assistant, agent, or automated workflow? These three get used interchangeably, but they differ in one practical way: who, or what, decides the next step, and that difference is exactly what decides how much governance each one needs around it. | Term | Decides the next step | Typical governance need | | AI assistant | A person, for each request | None beyond normal account access | | AI agent | The agent itself, within its tools and permissions | Guardrails, tool permissions, human in the loop for sensitive actions | | Automated workflow | A fixed, predefined sequence, no runtime choice | Change control on the workflow definition itself | An agent lead sits above this table rather than inside it: it is the process that assigns a ticket to an agent in the first place and reviews what comes back, whether that agent behaves closer to an assistant on a narrow task or a fully autonomous actor on a broader one. #### The 12 terms at a glance | Term | One-sentence definition | | Agent | A process that executes a task on its own, usually by calling tools. | | Agent lead | Acts for one person, assigns tickets, reviews every delivery. | | Runner | The machine or container where an agent executes: Mac, Windows, Linux binary, or Docker. | | MCP | An open protocol connecting LLM applications to external tools and data. | | MCP server and tool | A server exposing callable tools, such as reading a ticket, that an agent can call. | | Tool permissions | Rules on which tools an agent or sub-agent may call. | | Guardrail | An enforced limit on an agent's actions, not a suggestion. | | Human in the loop | A sensitive action waiting for one-time human approval. | | Audit log | A record of who did what, without the content of the work. | | Traceability | Following a ticket from brief to integrated change, state by state. | | Organization isolation | Project data encrypted per organization, with its own key chain. | | Shadow AI | Agents or MCP servers run outside a sanctioned platform, invisible to its controls. | A platform that defines these 12 terms this precisely, and is specific about which of them it actually enforces today rather than plans to add later, such as an extended audit log or the exact encryption chain behind organization isolation, is easier to evaluate on its own merits than one that uses the same 12 words as marketing shorthand. That same precision also makes it possible to compare two platforms on exactly these 12 points, rather than on whichever subset each vendor chooses to highlight. Q: Is an AI agent the same thing as an AI assistant? A: No. An assistant waits for a person to decide each next step; an agent decides its own next step within its tools and permissions, which is why guardrails and human-in-the-loop approval matter more for agents than for assistants. Q: Does MCP itself enforce governance like guardrails or audit logs? A: No. MCP is a protocol for connecting an LLM application to tools and data; guardrails, audit logs, and approval rules are built by the platform that uses MCP, not by the protocol itself. Q: Can a platform detect shadow AI by itself? A: Not necessarily. Atipol, for example, does not, on its own, detect agents or MCP servers installed outside the platform, so organization isolation and audit logs cover what happens inside the platform, not what runs outside it. Sources: - Model Context Protocol, Specification 2025-06-18: https://modelcontextprotocol.io/specification/2025-06-18 - Model Context Protocol, Tools (server spec), 2025-06-18: https://modelcontextprotocol.io/specification/2025-06-18/server/tools.md - Atipol, product reference for AI agents (llms-full.txt), 10 Nov 2026: https://atipol.ai/llms-full.txt - Atipol, security and encryption, 9 Nov 2026: https://atipol.ai/security ### Best AI Agent Governance Platforms 2026, by Category Source: https://atipol.ai/blog/ai-agent-governance-platforms-2026-list Author: Younes Azabar, founder of ETCSEC A DSI typing "best AI agent governance platforms 2026" into Google gets seven vendors that do not compete with each other directly, because they fall into four separate categories, not one. Each solves a different part of the problem. This list sorts seven named platforms, including Atipol, into those four categories, with a dated official source and an honest limit stated for each one. #### Why the same search turns up very different products A DSI or RSSI typing "best AI agent governance platforms 2026" into Google or ChatGPT gets results that do not compete with each other directly. Microsoft and Okta sell agent identity. ServiceNow and IBM sell enterprise control towers. Check Point and Galileo sell runtime guardrails. Atipol sells governed orchestration for smaller teams. Comparing all seven on one scorecard, without naming the category first, produces a shortlist that looks objective but is not. This list groups seven named platforms into four categories before comparing any single feature. Each entry below cites one official, dated page published by the vendor itself, not a review site, an analyst blurb, or a competitor's comparison page. Where a vendor's own material states a limit, such as a planned feature or a capability it does not offer, that limit is stated here as plainly as the feature itself. Atipol appears in its own category, governed orchestration for smaller teams, rather than stretched to compete with enterprise control towers it was never built to replace. The goal of this list is an honest category map, not a ranking that quietly favors one vendor by comparing it against products built to solve a different problem at a different scale. Category first, then features: Comparing seven platforms on one scorecard, before naming which of the four categories each belongs to, produces a shortlist that looks objective but is not: it compares products built to solve different problems, at different scales. #### Category 1: giving each agent its own identity Microsoft Entra Agent ID treats an AI agent as an account inside Microsoft Entra ID. Its governance overview page, with content updated 07/11/2026, states that agent identities are accounts within Microsoft Entra ID that provide unique identification, authentication, and authorization capabilities for AI agents, and that conditional access policies evaluate agent context and risk, including agent identity risk from Microsoft Entra ID Protection, before granting access. Governance capabilities such as access packages and sponsor-based lifecycle tasks extend Microsoft Entra ID Governance to agents, with a named human sponsor accountable for each agent's access over time. Microsoft's documentation requires one of two licensing paths to use Entra ID Governance with agent identities: a Microsoft 365 E7 subscription, which includes Agent 365 and Microsoft Entra Suite, or a Microsoft Agent 365 license paired with at least Microsoft Entra P1 or Microsoft 365 E3; a base Entra ID subscription alone does not include them. Okta for AI Agents takes the same identity-first approach from a different starting point. Okta's newsroom announced Agent SSO general availability on 24/08/2026, describing the broader Okta for AI Agents offering as a product that discovers, onboards, protects, and governs every agent across the enterprise. Agent SSO itself ships within Okta's core SSO offerings, while the broader governance suite is sold as a separate subscription. Both products assume an organization already using Microsoft Entra ID or Okta as its workforce identity system, with a team ready to extend that same discipline to agents. Neither one writes agent code, assigns tasks, or reviews tickets. Each answers precisely one question, which human account an agent's access ties back to, and leaves what the agent actually does to other software. #### Category 2: enterprise control towers for AI at scale ServiceNow's AI Control Tower expanded in 2026 around five stated functions: discover, observe, govern, secure, and measure. ServiceNow's newsroom release, dated 05/05/2026, describes a kill switch for an agent operating beyond its permissions and frames the expansion as giving organizations the control they need as agents take on more critical work across connected systems. That same release describes general availability of the expanded capabilities as expected in August 2026, a forward-looking date at the time of writing that is worth re-checking against ServiceNow's current documentation rather than assuming already shipped on schedule. IBM took a related but distinct path, merging two existing products rather than building a new control tower. IBM's newsroom announcement, dated 18/06/2025, unified watsonx.governance with Guardium AI Security, so that AI use cases discovered by Guardium automatically trigger governance workflows inside watsonx.governance, without a separate manual handoff between the two tools. IBM states that watsonx.governance can monitor and manage AI agents across their full lifecycle, from development through deployment, inside that combined view. ServiceNow's and IBM's products both assume an enterprise already running their respective stack at scale, with a dedicated AI risk function and a governance budget covering models, data, and agents together, not agents alone. #### Category 3: runtime guardrails and agent observability Check Point announced on 16/09/2025 that it had agreed to acquire Lakera. Check Point's release describes Lakera as one of the world's leading AI-native security platforms for agentic AI applications, with a platform that combines advanced runtime protection with continuous red teaming. That same release states the deal was expected to close in the fourth quarter of 2025, and it does not disclose an acquisition amount. Galileo had built an open source agent governance project called Agent Control, announced in 2026. Cisco has since completed its acquisition of Galileo, and Splunk's leadership blog, dated 28/05/2026, states that Galileo's technology will be built into Splunk Observability's AI Agent Monitoring, adding real-time guardrails that block unwanted outputs and low-cost evaluation through Galileo's Luna-2 models. Splunk's current product page presents this offering as Splunk Agent Observability; it no longer documents Agent Control by name, license, or the original launch partner list, so those specific details are no longer independently verifiable against a live source. This category catches a single failing tool call, a prompt injection attempt, or an agent trying to use a tool outside its allowed scope, at the moment it happens. That level of runtime detail is not what an identity platform or an enterprise control tower is built to inspect inside a single agent turn. #### Category 4: governed orchestration for smaller teams Atipol fits a fourth category: a smaller platform where a human agent lead supervises a team of AI agents working on real tickets. Every person has their own agent lead, and that agent lead never holds more rights than the person it acts for. Agents run on Mac, Windows, a Linux binary, or a Docker runner. Your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged. Admin decisions on tool requests outside the approved catalog are logged in the audit log. Atipol is not open source. Enterprise SSO with SAML 2.0 or OIDC is planned, not available today; the same is true for a self-hosted version and a customer-held encryption key. Login works today with Google or GitHub. Atipol does not, on its own, detect agents or MCP servers installed outside the platform, a limit covered in more operational terms at https://atipol.ai/agentic-ai-blog/mcp-security. All three of these, SSO, self-hosting, and shadow AI detection, are roadmap items, presented here as such rather than as shipped features. #### Seven platforms, one table The table below places all seven platforms side by side on what each actually governs, whether an agent's access ties back to a named person, and its stated status as of November 2026, using only what each vendor's own dated page states, without filling gaps with assumptions. | Platform | Category | What it governs | Agent access ties to a named owner | Stated status (vendor, 2026) | | Microsoft Entra Agent ID | Identity | Agent sign-in and conditional access | Yes, via a human sponsor | Requires Microsoft 365 E7, or Agent 365 plus Entra P1/M365 E3 | | Okta for AI Agents | Identity | Agent SSO and lifecycle | Yes, named owner required | Agent SSO generally available since 24/08/2026 | | ServiceNow AI Control Tower | Control tower | Discover, observe, govern, secure, measure | Not specified at the person level | Expansion announced 05/05/2026, general availability expected August 2026 | | IBM watsonx.governance | Control tower | Agent lifecycle monitoring via Guardium AI Security | Not specified at the person level | Unified with Guardium AI Security since 18/06/2025 | | Check Point AI Agent Security | Runtime guardrails | Pre-deployment posture checks and real-time runtime enforcement | Not an identity system | Lakera acquisition announced 16/09/2025 | | Galileo / Splunk Agent Observability | Runtime guardrails | Runtime evaluation, observability, and guardrails for agents | Not an identity system | Acquired by Cisco; integration into Splunk Observability announced per Splunk's 28/05/2026 blog | | Atipol | Governed orchestration | Scope, tool catalog, audit log | Yes, one agent lead per person | SSO, self-hosting, and customer key planned for Enterprise | #### How to pick a category before comparing vendors inside it Start by naming the problem, not the product. A team already running Microsoft Entra ID or Okta that just needs to extend workforce identity to agents fits category one. A team already running ServiceNow or IBM at enterprise scale, with a dedicated AI risk function in place, fits category two. A team worried about one specific runtime risk, such as prompt injection or an agent calling the wrong tool mid-task, fits category three. A smaller team that wants a human agent lead overseeing a handful of AI agents on real tickets, without the overhead of enterprise identity or GRC, fits category four. Only after naming the category does a feature-by-feature comparison make sense. Comparing Atipol to ServiceNow's AI Control Tower on enterprise-wide GRC breadth, or to Okta on workforce-scale agent SSO, compares products that were never built to solve the same problem. Atipol's framework for scopes, tools, and audit logs is at https://atipol.ai/agentic-ai-blog/ai-agent-governance, specifically for category four. The table below turns that same logic into four starting points, one per category. | Category | Fits if your team... | Platforms in this article | | Category 1: Identity | Already runs Microsoft Entra ID or Okta and just needs to extend identity to agents | Microsoft Entra Agent ID, Okta for AI Agents | | Category 2: Control tower | Already runs ServiceNow or IBM at enterprise scale, with a dedicated AI risk function in place | ServiceNow AI Control Tower, IBM watsonx.governance | | Category 3: Runtime guardrails | Worried about one specific runtime risk, such as prompt injection or an agent calling the wrong tool mid-task | Check Point AI Agent Security, Galileo / Splunk Agent Observability | | Category 4: Governed orchestration | Smaller team that wants a human agent lead overseeing a handful of AI agents on real tickets | Atipol | The same four categories, as a diagram: Diagram (tree) - Name the problem first - Category 1: Identity: Already runs Entra ID/Okta - Category 2: Control tower: Already runs ServiceNow/IBM - Category 3: Runtime guardrails: One specific runtime risk - Category 4: Governed orchestration: Wants a human agent lead - Microsoft Entra Agent ID - Okta for AI Agents - ServiceNow AI Control Tower - IBM watsonx.governance - Check Point AI Agent Security - Galileo / Splunk Observability - Atipol Name the problem first -> Category 1: Identity Name the problem first -> Category 2: Control tower Name the problem first -> Category 3: Runtime guardrails Name the problem first -> Category 4: Governed orchestration Category 1: Identity -> Microsoft Entra Agent ID Category 1: Identity -> Okta for AI Agents Category 2: Control tower -> ServiceNow AI Control Tower Category 2: Control tower -> IBM watsonx.governance Category 3: Runtime guardrails -> Check Point AI Agent Security Category 3: Runtime guardrails -> Galileo / Splunk Observability Category 4: Governed orchestration -> Atipol #### Common mistakes when shopping this category The first mistake is treating a roadmap item as a shipped feature. Several vendors in this list state a capability as planned or expected rather than live today; ServiceNow's own release frames its expanded general availability as expected in August 2026, which is worth re-checking before a renewal decision rather than assumed to have shipped on schedule. The second mistake is assuming shadow AI discovery is universal across this category. Okta for AI Agents discovers unregistered and shadow AI agents through browser, endpoint, and network detection, a capability Okta documents in its own newsroom material, but not every vendor in this list documents the same discovery capability. Atipol does not detect agents or MCP servers installed outside the platform on its own, a limit worth testing before, not after, signing a contract. The third mistake is skipping the vendor's own dated source in favor of a review site or a sales deck. Every entry in this list links to an official page published by the vendor itself. Re-reading that same page at renewal time, not only at purchase time, is the only reliable way to catch a quietly expired roadmap promise. Atipol's comparison page lines up Atipol against other agent platforms using the same kind of dated detail used throughout this list, at https://atipol.ai/comparison, which is a reasonable next stop once a team has picked the right category for its own problem. Q: What is an AI agent governance platform? A: It is software that manages what an AI agent can access, who it reports to, and what it did, the same way an IT team manages employee access. In 2026 that single label covers at least four different products: agent identity providers, enterprise control towers, runtime guardrails, and smaller governed orchestration tools such as Atipol. Q: Do these platforms detect shadow AI on their own? A: Not universally. Okta for AI Agents discovers unregistered and shadow AI agents through browser, endpoint, and network detection, a capability confirmed in Okta's own newsroom material. Atipol does not, on its own, detect MCP servers or agents installed outside the platform; it instead logs administrator decisions on tool requests outside its approved catalog. Q: Does Atipol compete directly with ServiceNow's AI Control Tower or Microsoft Entra Agent ID? A: No. Those products cover enterprise-wide AI governance, including models and data outside any single agent, and assume a dedicated AI risk team. Atipol covers a narrower problem: a human agent lead supervising a small team of AI agents on tickets, with its own scope, audit log, and encryption model. Sources: - Microsoft Learn, Agent ID governance overview, updated 07/11/2026: https://learn.microsoft.com/en-us/entra/id-governance/agent-id-governance-overview - Okta newsroom, Agent SSO general availability, 24/08/2026: https://www.okta.com/newsroom/press-releases/okta-brings-first-class-identity-to-ai-agents-with-agent-sso/ - ServiceNow newsroom, AI Control Tower expansion, 05/05/2026: https://newsroom.servicenow.com/press-releases/details/2026/ServiceNow-expands-AI-Control-Tower-to-discover-observe-govern-secure-and-measure-AI-deployed-across-any-system-in-the-enterprise/ - IBM newsroom, unifying agentic governance and security, 18/06/2025: https://newsroom.ibm.com/2025-06-18-ibm-introduces-industry-first-software-to-unify-agentic-governance-and-security - Check Point press release, acquisition of Lakera, 16/09/2025: https://www.checkpoint.com/press-releases/check-point-acquires-lakera-to-deliver-end-to-end-ai-security-for-enterprises/ - Splunk leadership blog, Cisco completes acquisition of Galileo, 28/05/2026: https://www.splunk.com/en_us/blog/leadership/splunk-observability-galileo.html ### 7 AI Agent Controls: Who Owns Each, What Proves It Source: https://atipol.ai/blog/control-ai-agents-enterprise-7-controls Author: Younes Azabar, founder of ETCSEC A framework on paper proves nothing on the day an incident review asks who approved an AI agent's production access and where the record is. This checklist maps seven controls to a specific owner, a specific artifact to keep, and a NIST AI RMF subcategory, building on Atipol's six-step governance framework rather than repeating it. #### Having a framework is not the same as proving it runs A DSI telling an executive committee that AI agents are under control usually means two different things are true at once: a framework exists on paper, and nobody can produce the record that proves it was followed for the agent that just shipped to production last week. The harder, more frequent question is not which controls a framework lists, but who owns each one day to day and what artifact an auditor, a regulator, or an incident review can actually pull up as proof. This gap matters more as agents move from a pilot a few people use to a system touching customer data, financial reports, or production code. A framework that lives only in a policy document answers the first question, the one about completeness. It does not answer the second one, about evidence, which is the one that actually gets tested the week something goes wrong and someone asks who approved it and where the record is. That gap also complicates a question boards ask more directly every quarter: can the organization show, agent by agent, that production access was earned rather than granted by default. A framework answers that only in the aggregate; the evidence described below is what answers it one agent at a time, which is the level an incident review or a regulator actually asks the question at. Framework vs. evidence: A framework describes what should happen in general; evidence proves it happened for one named agent, one named owner, and one dated artifact. An audit, a regulator, or an incident review tests the second one, not the first. #### Building on six steps, not rewriting them A six-step framework, inventory, job description and scope, rights and tools, tickets with written criteria, human review before merging, and cost measurement with an audit log, is already covered at atipol.ai/agentic-ai-blog/ai-agent-governance, along with the RACI table and sample usage policy that go with it. Repeating that framework here would not add anything a DSI does not already have. What follows instead maps each of those steps, plus one more, to a specific owner and a specific piece of evidence, using the NIST AI Risk Management Framework's own Govern function as the vocabulary for what regulators and auditors already expect that evidence to look like. #### Seven controls, seven owners, seven artifacts Each row below assumes the underlying control already exists, described in the governance guide linked above, and asks the next question: who is accountable for it running, and what do they hand over when asked to prove it. | Control | Owner | Evidence kept | | Inventory of active agents | Whoever maintains the catalog (per NIST Govern 1.6) | A dated list naming each agent, its agent lead, and its project | | Job description and file scope | The agent lead who declared the agent | The written scope and forbidden actions, reviewed before first run | | Role-based tool permissions | The administrator who set the catalog mode | An exported permission list, allowed, approval, or denied, per tool | | Approval before sensitive or irreversible actions | The approver named at the time of the call | A log entry linking the call, the approver, and the decision | | Review before merge, by someone other than the requester | A reviewer distinct from the person who opened the ticket | The reviewed diff and the merge decision, not only the agent's summary | | Risk and impact documented per agent (NIST Govern 4.2) | The team that designed or deployed that agent | A short risk note kept alongside the job description | | Contingency for a third-party model or MCP server (NIST Govern 6.1/6.2) | Whoever owns the dependency on that provider | A documented fallback if the provider changes, fails, or is deprecated | #### What NIST's own Govern function expects as evidence The first four rows above are not an invention; they translate language already written into the NIST AI Risk Management Framework's Govern function. Govern 2.1 requires that "roles and responsibilities and lines of communication related to mapping, measuring, and managing AI risks are documented... and are clear to individuals and teams throughout the organization," and the framework's own Playbook turns that into a documentation question an auditor would ask directly: "Are the responsibilities of the personnel involved in the various AI governance processes clearly defined?" An agent lead's name on an inventory entry is one concrete answer to that question; a policy document describing agent leads in the abstract is not. Govern 1.6 does the same for the inventory itself, requiring "mechanisms... in place to inventory AI systems... resourced according to organizational risk priorities," with the Playbook asking "who is responsible for documenting and maintaining the AI system inventory details." The answer has to be a name or a role, not a statement that an inventory exists somewhere. Govern 2.3 adds a layer above the agent lead: "Executive leadership of the organization takes responsibility for decisions about risks associated with AI system development and deployment." Read alongside the first two subcategories, the chain an auditor is really checking runs from a declared agent, to a named agent lead, to an executive who accepted the risk of developing and deploying it, not from a framework document to an assumption that someone, somewhere, is accountable. Read together, the three subcategories above describe a chain of accountability: Diagram (flow) - Declared agent: Govern 1.6 - Named agent lead: Govern 2.1 - Executive: Govern 2.3 Declared agent -> Named agent lead Named agent lead -> Executive The Playbook's suggested actions for these same subcategories are written the same way, as policies an organization adopts rather than abstract goals: for Govern 2.1, "Establish policies that promote regular communication among AI actors participating in AI risk management efforts"; for Govern 1.6, "Establish policies that define a specific individual or team that is responsible for maintaining the inventory." Both point back to the same artifact, a named person or team written into a policy, rather than a diagram of roles that nobody is required to keep current. None of these four subcategories require new tooling to satisfy; they require the inventory entry, the job description, and the executive sign-off to exist as named, dated records rather than as a shared understanding inside the team that built the first agent. The NIST language above is the vocabulary an external reviewer will likely already use, which is one reason to produce evidence in those terms rather than inventing a different one. #### Documenting risk and impact per agent, not only per project Govern 4.2 asks organizational teams to "document the risks and potential impacts of the AI technology they design, develop, deploy, evaluate," which in practice is a short note attached to each agent's job description, not a single risk assessment covering an entire platform. The NIST Playbook frames this as something that can "be applied at the beginning of a process but also iteratively and regularly since goals and outcomes can evolve over time," and that can "assist in 'go/no-go' decisions for an AI system," which is the operational version of the sixth row in the table above: a risk note a team updates, not a document written once and filed. Govern 6.1 and 6.2 extend the same logic to what an agent depends on outside the organization: "policies and procedures... that address AI risks associated with third-party entities," and "contingency processes are in place to handle failures or incidents in third-party data or AI systems deemed to be high-risk." That second requirement is explicitly scoped to dependencies judged high-risk, not every third-party connection; for an agent built on a model or an MCP server the organization treats that way, the contingency plan, what happens if the provider changes terms, deprecates an endpoint, or has an outage, is the seventh control, and the one most often missing because it sits outside the team that built the agent. Neither Govern 4.2 nor Govern 6.1/6.2 specifies a template for this note or this plan, which is deliberate: a risk note for an internal support agent and one for an agent that touches financial reporting will not look the same, and a contingency plan should name the actual provider and the actual fallback, not a generic statement that one exists somewhere in an incident response document. #### The reviewer in your evidence cannot be the requester The fifth row's evidence is only as good as who is named in it. GitHub's own documentation on reviewing a pull request created by its Copilot coding agent makes the same requirement explicit for a comparable workflow: an approval from the person who assigned the work does not count toward a repository's required reviews, and a different reviewer has to approve the change before merge. The evidence an auditor wants here is not a timestamp showing a review happened, it is the reviewer's identity checked against the requester's, which a log that only records "reviewed: yes" cannot provide. The same applies to the fourth row: an approval log that cannot distinguish the approver from the agent, or from the person who triggered the call, documents that something happened without documenting the control it was supposed to satisfy. #### Evidence has a review cadence of its own A control that was true when the framework launched is not automatically true six months later: an agent's scope can expand, a reviewer can leave the project, a third-party model can change its terms. Treating the inventory, the risk notes, and the permission list as live records to revisit on a fixed schedule, rather than documents produced once for a launch review, is what keeps the evidence in row one through seven matching what the agents are actually doing, instead of describing a system that existed at the time of the last audit. This is also where the sixth and seventh controls differ most from the first five: an inventory entry or a permission list can be checked against the system itself, but a risk note and a contingency plan age silently, since nothing breaks visibly when they go stale until the day the scenario they were supposed to cover actually happens. The same Playbook guidance that asks who maintains the inventory does not set a review interval either, which mirrors the pattern across every Govern subcategory cited here: NIST specifies the artifact and the accountable role, not a calendar. An organization still has to pick that cadence itself, and the safest default is to tie it to events that already happen, a new agent declared, a reviewer leaving a project, a provider changing terms, rather than to a fixed date on a compliance calendar alone. #### Putting the ownership and evidence model into practice None of these seven controls replace the framework, the RACI table, or the usage policy already described at atipol.ai/agentic-ai-blog/ai-agent-governance; they name who is accountable for each one and what to keep on hand when someone asks for proof. The underlying permission model, the approval logging, and the MCP server review practice that produce much of this evidence are covered at atipol.ai/agentic-ai-blog/mcp-security, and the guided tour of applying all of it across a team of agents is at atipol.ai/security. Q: What is the difference between an AI agent governance framework and the controls described here? A: The framework, inventory, scope, tool rights, ticket criteria, review before merge, and cost tracking, already exists, covered at atipol.ai/agentic-ai-blog/ai-agent-governance. This checklist adds an owner and a specific piece of evidence to each of those steps, plus a seventh control for third-party dependencies, so a DSI can produce proof the framework is actually being followed. Q: Which NIST AI RMF subcategories apply to enterprise AI agent control? A: Govern 2.1 covers documented roles and responsibilities, Govern 1.6 covers maintaining an AI system inventory with a named owner, Govern 2.3 covers executive accountability for decisions about AI system development and deployment, Govern 4.2 covers documenting risks and impacts per system, and Govern 6.1 and 6.2 cover policies and contingency plans for third-party AI dependencies judged high-risk. Q: Who should own the inventory of AI agents running in an organization? A: NIST's AI RMF Playbook frames this as a named individual or team responsible for maintaining the inventory details, not an assumption that it exists somewhere. In Atipol's model, that maps to each agent's declared agent lead at the entry level and an administrator or organization owner at the catalog level. Sources: - NIST, AI Risk Management Framework 1.0, Govern Core, consultée le 11/11/2026: https://airc.nist.gov/airmf-resources/airmf/5-sec-core/ - NIST, AI Risk Management Framework 1.0 Playbook, Govern, consultée le 11/11/2026: https://airc.nist.gov/AI_RMF_Knowledge_Base/Playbook/Govern - GitHub Docs, Reviewing a pull request created by Copilot, consultée le 11/11/2026: https://docs.github.com/en/copilot/how-tos/agents/copilot-coding-agent/reviewing-a-pull-request-created-by-copilot ### AI Agent Sovereignty: Four Answers, Not One Source: https://atipol.ai/blog/sovereign-ai-agent-governance Author: Younes Azabar, founder of ETCSEC A DSI asking where an AI agent's code and data actually go gets four different answers at Atipol, not one. Repository content stays on your own machines; only a file list and version reference are sent. Project data such as tickets is stored encrypted per organization, under a hardware master key, with every access checked and logged, which is not the same as legal immunity. #### What "AI agent data sovereignty" actually means A DSI or RSSI typing "souveraineté agents IA" or "where does my code go" into Google or ChatGPT is usually trying to answer one practical question before signing with any AI agent platform: what leaves our machines, what gets stored somewhere else, and who can be forced to hand it over. That question has at least four separate answers, not one. The first answer is about code: does the platform read, copy, or transmit your repository content. The second is about project data: tickets, specifications, and history generated while agents work. The third is about encryption: what algorithm protects that data, and who holds the keys. The fourth is about jurisdiction: which country's laws can reach the infrastructure, regardless of which region the data physically sits in. This article answers all four for Atipol, based only on what Atipol states at https://atipol.ai/llms-full.txt, checked here against the live page, alongside an official French regulator's note on a separate but related risk: hosting inside the EU does not automatically remove exposure to a non-EU parent company's legal obligations. #### What never leaves your machines: repository content Atipol states plainly, at https://atipol.ai/llms-full.txt, that repository content stays on your machines. A delivery sends the reference of the delivered version and the list of changed files, never their contents. An agent working inside your repository does not transmit file contents or diffs back to Atipol's servers at any point in that delivery step. What Atipol does receive, and store, is narrower than the repository itself: the scope and the list of delivered files, meaning file paths and line counts, stored encrypted per organization. That is a meaningful distinction for a DSI evaluating exposure: metadata about what changed is stored in Atipol's SaaS, even though the changed content itself is not. This is the part of the sovereignty question that is usually the most urgent for a team worried about proprietary code leaving its own infrastructure. It does not, however, answer the second question, what happens to the project data generated around that code, which is addressed next. #### What Atipol's SaaS does store, and how it is encrypted Project data, tickets, specification documents, and ticket history, is stored in Atipol's SaaS rather than on a customer's own machines. It is encrypted per organization, under a hardware master key, so one organization's data is never pooled with another's. Every access to that data is checked against the person's rights and logged: each action is attributed to a person, an agent, and a machine, which gives a DSI a reviewable trail rather than a black box. How stored project data is protected, as a diagram: Diagram (tree) - Your project data: Tickets, specs, history - Encrypted per organization: Under a hardware master key - Every access checked: Against your rights, and logged Your project data -> Encrypted per organization Encrypted per organization -> Every access checked Encrypted per organization means the server opens project content according to a person's rights in order to run the product; it does not mean the vendor could never read it. A DSI comparing vendors should keep that distinction in view rather than read "encrypted" as "unreadable by the vendor". Access to that stored data is also scoped rather than all-or-nothing. Atipol describes, at https://atipol.ai/llms-full.txt, permissions set tool by tool, where a new tool starts out denied until a person approves it, and lists named roles, including Admin, Workspace owner, Project lead, Contributor, Reader, and Auditor, each with a different reach into a project's stored data. That role structure is a separate control from encryption itself, and a DSI evaluating sovereignty should check both. Encrypted per organization, opened only according to rights: Your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged. #### The honest limit: where a key is hosted does not mean immunity from non-EU law Where data and keys are hosted is a real control. It does not, on its own, remove every legal question a DSI might reasonably ask, because a cloud provider operating the underlying infrastructure may itself be subject to obligations outside EU law, the exact scenario Chapter V of the GDPR, Regulation (EU) 2016/679, on international data transfers, was written to address. The CNIL made a closely related point in a note dated 19/07/2024: data stored by a provider subject to non-European law, such as a hosting company whose parent company sits in the United States, can be exposed to a risk of having to communicate that data to that country's public authorities, even where the hosting itself happens inside the EU. The CNIL's own note frames this risk as most often considered limited specifically for non-sensitive data entrusted to a provider from a country recognized as offering an adequate level of protection, such as the United States under the European Commission's adequacy decision, and it reserves its strongest concern for the most sensitive categories of data, such as large health databases. A DSI should read that narrower nuance rather than generalize it to all processing, or treat the risk as either absent or certain. The operational conclusion for a team evaluating Atipol, or any SaaS platform with a comparable architecture, is to separate two different questions: where is the data physically hosted, and which country's legal obligations can reach the company operating that hosting. Atipol addresses the first question; it does not, and should not, claim to resolve the second on a customer's behalf. Atipol's guide on agentic AI, GDPR, and the AI Act, at https://atipol.ai/agentic-ai-blog/agentic-ai-gdpr-ai-act, covers the compliance side of that second question in more depth. #### What's planned, not available today: customer key and self-hosting Two capabilities that would change this picture are listed by Atipol as planned, not shipped. A customer-held encryption key, kept in the customer's own vault and revocable by the customer rather than by Atipol, is planned for the Enterprise plan. A self-hosted version of the platform, running on infrastructure the customer controls entirely, is listed as a later, Enterprise-oriented capability. Neither is available on any plan today. A DSI whose sovereignty requirement cannot be satisfied by organization-level encryption with a provider-held key, under the architecture described above, should treat these two items as a timeline question for Atipol directly, not assume either is already live. Atipol places the customer key, at https://atipol.ai/llms-full.txt, under its Enterprise plan description, alongside an extended audit log, both listed as planned rather than available today. Self-hosting is not tied to that same plan description; it appears separately, under a "coming soon" list, with no date more specific than "later." A DSI with a hard sovereignty deadline should ask Atipol directly for a committed date on either item rather than infer one from that wording. #### A hosting location is not a sovereign cloud certification It is worth being precise about what a hosting location does and does not establish. Hosting data in a given country is not the same thing as a sovereign cloud certification such as SecNumCloud, and Atipol does not claim that certification. For the jurisdiction question, what matters is which company operates the underlying infrastructure, a question worth putting to every vendor. #### What stays local, what's stored, and what's planned: one table The table below separates the sovereignty question into its four parts, using only what Atipol states at https://atipol.ai/llms-full.txt and what the CNIL's note states, rather than treating sovereignty as one single yes-or-no answer. Reading it top to bottom separates a claim that is fully true today, repository content, from one that is only partly true, project data, stored but encrypted, from one that is not made at all, immunity from non-EU legal reach, from one that is only a roadmap commitment, a customer-held key or self-hosting. Collapsing those four into a single "is Atipol sovereign" question obscures exactly the distinctions a DSI needs before signing. | Question | Status today | Where it's confirmed | | Repository content (code, diffs) | Stays on your machines; never sent | Atipol, llms-full.txt, 10/11/2026 | | File paths and line counts of a delivery | Sent and stored, encrypted per organization | Atipol, llms-full.txt, 10/11/2026 | | Project data (tickets, history) | Stored in Atipol's SaaS, encrypted per organization | Atipol, llms-full.txt, 10/11/2026 | | Master key | Hardware master key; every access checked and logged | Atipol, security page | | A vendor that can never read the data | Not claimed; the server opens content according to rights | Atipol, llms-full.txt, 10/11/2026 | | Immunity from non-EU legal reach on the cloud provider | Not claimed; flagged as a general risk for non-EU-law providers | CNIL, 19/07/2024 | | Customer-held key / self-hosting | Planned for Enterprise; not available today | Atipol, llms-full.txt, 10/11/2026 | #### Common mistakes when assessing AI agent sovereignty The first mistake is treating "our code stays local" and "our data is sovereign" as the same claim. On Atipol, the first is true for repository content; the second is more limited, since project data is stored by the SaaS and the master key sits on infrastructure operated by a US-headquartered cloud provider, even from a French region. The second mistake is reading "encrypted per organization" as a promise that the vendor can never read the data. Encryption per organization keeps one customer's data apart from another's and ties every access to a person's rights; it is not the same as a design in which the vendor itself can never open anything, and a DSI should not translate "encrypted" into that stronger claim on a vendor's behalf. The third mistake is assuming a planned roadmap item, such as a customer-held key or self-hosting, is already available because a competitor offers something similar today. Ask any vendor in this space for a committed date on roadmap items, and re-check that date at renewal rather than at signing only. A fourth, smaller mistake is stopping the review at encryption and key custody without also checking tool-level permissions and the audit trail, since a sovereignty review that ignores who can act on stored data inside the platform is incomplete even when the encryption answer is accurate. Atipol sets out how it protects data and logs every access at https://atipol.ai/security, alongside its guide on securing MCP servers connected to agents, at https://atipol.ai/agentic-ai-blog/mcp-security, which covers a closely related exposure a sovereignty review should not skip. Q: Does my source code ever leave my own machines when I use Atipol? A: No, not in content form. Repository content stays on your machines, and a delivery sends only the reference of the delivered version and the list of changed files, never their contents. That list, file paths and line counts, is stored encrypted per organization, but the code itself is not. This split, content never sent versus delivery records stored, is the distinction a sovereignty review needs to keep in view. Q: How is project data protected in Atipol? A: Your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged. The server opens project content according to a person's rights in order to run the product, so "encrypted" should not be read as "unreadable by the vendor". Q: Does where the master key is hosted make Atipol immune to US law? A: No claim like that is made, and a hosting location does not resolve that question on its own. The CNIL noted on 19/07/2024 that data held by a provider subject to non-European law, such as one with a US parent company, can face a risk of disclosure to that country's authorities, even when hosted inside the EU; it frames this risk as most often limited specifically for non-sensitive data handled by a provider from an adequate country, not as absent. Sources: - Atipol, llms-full.txt, last updated 10/11/2026: https://atipol.ai/llms-full.txt - CNIL, Cloud : les risques d'une certification européenne permettant l'accès des autorités étrangères, 19/07/2024: https://www.cnil.fr/fr/cloud-les-risques-dune-certification-europeenne-permettant-lacces-des-autorites-etrangeres - Regulation (EU) 2016/679 (GDPR), Official Journal, 04/05/2016: https://op.europa.eu/en/publication-detail/-/publication/3e485e15-11bd-11e6-ba9a-01aa75ed71a1 - Atipol, security page, updated 09/11/2026: https://atipol.ai/security ### How to Orchestrate Multiple AI Agents With Governance Source: https://atipol.ai/blog/governed-multi-agent-orchestration-brief-to-integration Author: Younes Azabar, founder of ETCSEC Teams that already enforce file scope and review before merge still see conflicts, because the failure starts earlier: an unsplit brief, not the parallel agents themselves. The chain that actually prevents conflicts, duplicate work, and unreviewed merges runs brief to tickets, tickets to parallel agents with reserved file scope, agents to review by someone else, and review to integration that reruns the project's own checks, regardless of which MCP client runs each agent. #### The failure starts before the first agent runs A CTO who says running agents in parallel creates conflicts, duplicates, and unreviewed deliveries has usually already fixed half the problem: a dedicated worktree and branch per agent, a reserved file scope per ticket, and review before merge, the five practices a related guide on this blog already covers, illustrated there with Claude Code but not limited to it. What breaks the chain before any of that applies is earlier: a brief that never became a set of distinct, scoped tickets in the first place, and a review and integration step that has to hold regardless of which client ran which agent. None of what follows repeats the worktree, scope, or review-before-merge practices already documented; it covers the two parts of the chain that sit on either side of them, turning a brief into tickets before parallel work starts, and coordinating review and integration once several deliveries land at the same time, built around the Model Context Protocol's own host-neutral architecture rather than one specific client. Treating the five practices and this chain as the same thing is the mistake that leads a team to adopt file scope and review, still see conflicts, and conclude the practices do not work; the practices solve what happens once tickets exist, and a team that skips straight to parallel agents from an unsplit brief is still exposed to the failure mode those five practices were never meant to catch. #### MCP's architecture is host-neutral, which is why the chain works with any client The protocol's own architecture overview, version 2026-07-28, describes MCP as a client-server model where an MCP host, "an AI application like Claude Code or Claude Desktop," creates one MCP client for each server it connects to, with each client holding a dedicated connection to its server. The documentation gives a second, different host as its own example: when Visual Studio Code connects to the Sentry MCP server and then to a local filesystem server, the Visual Studio Code runtime instantiates a separate client object for each one. That design is why a governance chain built on tickets, scope, and review does not have to be rewritten for every client: the host changes, Claude Code, Claude Desktop, VS Code, or any other application implementing the protocol, but the client-to-server connection model, and the tools, resources, and prompts a server exposes, stay the same underneath it. A ticket that names a file scope and an acceptance criterion constrains the agent regardless of which host happens to be running it that day. The same overview specifies two transport mechanisms underneath that client-server model, a stdio transport for a local server talking to one client on the same machine, and a Streamable HTTP transport for a remote server serving many clients at once, each carrying the identical JSON-RPC message format regardless of which transport or which host is on the other end. #### From brief to tickets: what has to be decided before parallel work starts A brief, written for a person, usually bundles several changes that touch different parts of a codebase or a dataset under one description. Splitting it into tickets a set of agents can run in parallel means deciding, before any agent starts, which parts of that brief can be worked on without touching the same files, which ones depend on another ticket finishing first, and which single ticket should instead absorb a change too entangled to split safely. Each resulting ticket still needs the two things a ticket-based governance model already requires: a file scope reserved before the agent launches, so two tickets in progress cannot claim the same files, and acceptance criteria written in advance, so the agent has a verifiable target and the reviewer has an objective test rather than the agent's own summary of what it did. Getting the split wrong here, overlapping scopes, or acceptance criteria copied verbatim from the original brief without being made specific to each ticket, is what produces the duplicate work and merge conflicts a CTO sees downstream, even when every other practice in the chain is followed correctly. A brief that bundles a database migration with an unrelated UI change is the clearest case for splitting before assigning agents, since the two touch disjoint files and carry independent risk; a brief that changes one function's signature and every file that calls it is the clearest case for keeping as a single ticket, since splitting it would hand two agents overlapping scope on the same change. #### The chain, stage by stage The table below names the control at each stage of the chain, from brief to integration, and where that control already appears in more detail elsewhere on this blog rather than repeating it here. | Stage | What has to happen | Where it's covered | | Brief to tickets | Split into non-overlapping file scopes, each with its own acceptance criteria | This article | | Ticket to parallel agent | Worktree and branch per agent, scope enforced before launch | Parallel Claude Code agents guide | | Agent to delivery | Tool list and available actions can change mid-run; agents resync via MCP notifications | MCP architecture overview | | Delivery to review | Reviewed by someone other than the requester, on the actual diff | AI agent governance guide | | Review to integration | Project's own checks rerun at merge, not assumed from the review alone | AI agent governance guide | #### Running agents in parallel without losing the thread Once several agents are running against their own reserved scopes, the coordination problem shifts from file conflicts to staying synchronized on what each agent is actually allowed to do. MCP's own notification system exists for exactly this: a server can tell connected clients when its available tools change, for example when a tool is added, modified, or temporarily disabled, and a client that subscribed to that notification refreshes its tool list rather than continuing to work from a stale one. For a team running several agents against the same MCP servers, that means a scope or permission change made mid-run, a tool newly blocked by an administrator, a server taken offline for maintenance, propagates to every connected agent through the protocol itself, instead of depending on each agent being restarted to pick up the change. This is an opt-in mechanism, not something a client gets automatically: the protocol's own documentation notes that change notifications are sent only to clients that subscribed to them, and that polling still has a role since delivery is best-effort rather than guaranteed, particularly across a reconnect. #### Review has to happen once, by someone who didn't do the work Running five tickets in parallel does not mean inventing five different review standards; it means the same rule, the person who asked for the work is not the one who approves it, applied to every delivery that lands, whether they arrive one at a time or all in the same afternoon. GitHub's own documentation on its Copilot coding agent states the same constraint for a comparable workflow: an approval from the person who assigned the work does not count toward a repository's required reviews. What changes under parallel load is not the standard, it is the volume a reviewer has to absorb at once, which is the reason the same practices guide already caps simultaneous sessions to what review can actually keep up with, rather than treating review capacity as unlimited just because the agents themselves can run in parallel. A cap on simultaneous sessions, already recommended elsewhere on this blog at three to five, is the practical form this takes: it is not a limit on how many agents a tool can run, it is a limit matched to how many deliveries one reviewer, or one review rotation, can actually read the diff for before approving. #### Integration reruns the checks, it doesn't trust the review alone A diff that passed review still merges into a shared history that every other in-progress ticket depends on, which is why the governance model this blog has already documented reruns the project's own checks at integration time, rather than relying solely on the review that preceded it. Under parallel work that step matters more, not less: two reviewed, approved tickets can still conflict with each other in ways neither reviewer saw in isolation, and integration is the point where that conflict actually surfaces. Treating integration as a second, independent check rather than a formality after review is what keeps a merge conflict from becoming a production incident discovered after the fact instead of a blocked merge caught before it. None of this requires a different tool for parallel work versus sequential work; the same rerun-at-integration step applies to a single ticket merging alone, it simply has more opportunities to catch something when several tickets land close together. #### Building the chain into a team The worktree, branch, and file-scope practices that make the parallel-agent stage of this chain work, cap included, are covered in full at atipol.ai/agentic-ai-blog/parallel-claude-code-agents. How the cost of running several agents in parallel is tracked per ticket rather than per month is covered at atipol.ai/agentic-ai-blog/ai-agent-costs, and the guided tour showing a ticket move from brief to parallel work to review to integration end to end is at atipol.ai/tour. Q: Does a governed multi-agent orchestration chain work with AI clients other than Claude Code? A: Yes. The Model Context Protocol's own architecture is host-neutral: its documentation describes Claude Code, Claude Desktop, and Visual Studio Code as examples of hosts that each create their own MCP client per server, with the same client-server connection model underneath. A chain built on tickets, file scope, and review constrains the agent regardless of which host is running it. Q: What has to be decided before splitting a brief into tickets for parallel agents? A: Which parts of the brief touch different files and can run without overlap, which parts depend on another ticket finishing first, and which parts are too entangled to split safely and should stay as one ticket. Each resulting ticket still needs its own reserved file scope and acceptance criteria written before the agent launches. Q: Why rerun checks at integration if a delivery was already reviewed? A: Because a review covers one diff in isolation, while integration is where that diff meets every other change merged since the review started. Two separately reviewed and approved tickets can still conflict with each other in ways neither reviewer saw, which is why rerunning the project's own checks at merge time catches what review alone cannot. Sources: - Model Context Protocol, Architecture overview (protocol version 2026-07-28), accessed 11/11/2026: https://modelcontextprotocol.io/docs/learn/architecture - GitHub Docs, Reviewing a pull request created by Copilot, accessed 11/11/2026: https://docs.github.com/en/copilot/how-tos/agents/copilot-coding-agent/reviewing-a-pull-request-created-by-copilot - NIST, AI Risk Management Framework (AI RMF 1.0), published 26/01/2023: https://www.nist.gov/itl/ai-risk-management-framework ### Credo AI Alternative: What's GA, What's Preview Source: https://atipol.ai/blog/credo-ai-alternative-agent-governance Author: Younes Azabar, founder of ETCSEC Credo AI already claims the agentic era on its homepage, but the one feature built to govern agents day to day, Agent Governor, is still labeled Research Preview, not generally available. That leaves tickets, tool permissions, and review before merge as a gap Atipol covers today, which the two tools can close together rather than one replacing the other. #### Credo AI covers more ground than the pain suggests A DSI who says Credo AI covers model compliance but nobody governs what agents do day to day is reacting to a real gap, but not quite the one Credo AI's own homepage describes. Credo AI's site states it "created the AI governance category, and is defining it for the agentic era," under the heading "AI Governance, Built for the Agentic Era," and its AI Registry is described as covering agents alongside models, applications, and workflows, with an Agent Registry, Agent Cards, and a dedicated Agent Governance capability already named in its product menu. The nuance the pain misses is not whether Credo AI addresses agents at all, it does, on paper, but which part of that agent story is shipped today and which part is still a preview. Credo AI's own site marks its core platform, GAIA, as "generally available in the platform today," while its dedicated Agent Governor is marked "Research Preview," the vendor's own label for a feature not yet generally available. That distinction matters more than a feature checklist, because a DSI deciding what to run in production this quarter needs to know which governance layer is shipped, not which one is on a roadmap slide. Treating Credo AI as if it had no agent story at all would be its own factual error, the same category of mistake this blog avoids when citing any vendor; the accurate claim is narrower and still useful: an agentic ambition stated on the homepage, backed by a registry and a named Agent Governance capability, with the one feature that would operationalize it still in preview. #### What's GA today, and what's still a research preview Credo AI's Policy Engine, described as turning "policy into code" with pre-built policy packs, regulatory intelligence, automated workflows, and audit-ready evidence, ships ready-to-deploy packs for the EU AI Act, NIST AI RMF, and ISO 42001, with OMB M-25, Colorado's AI discrimination law, and NAIC's AI model bulletin also listed among the frameworks the platform covers. None of that is marked as a preview on the page; it sits under GAIA, the platform the site states is generally available. The AI Registry, described as discovering and cataloging "every AI system, agent, vendor and model," lists shadow AI detection among its capabilities, alongside the Agent Registry and Agent Cards. Agent Governance itself is summarized on the page as a "registry for every agent, purpose-built agentic risk and controls, and governance," which is the ambition; Agent Governor, the specific feature carrying that promise forward, is the one piece explicitly marked Research Preview. This split is consistent across the page: wherever a capability is described as already running inside GAIA, no release qualifier appears next to it; wherever a capability is described as part of the agentic push specifically, Agent Governor, the preview label is the one qualifier the page attaches. #### What the registry documents, and what it does not yet operationalize A registry that catalogs every agent, scores its risk, and flags where it is unmanaged answers an inventory and compliance-reporting question: which agents exist, which framework's controls apply to them, and where the evidence for an audit lives. It does not, by itself, answer an operational question a DSI asks about a specific agent on a specific day: who approved this ticket, which tools could this agent call, and who reviewed the diff before it merged. Nothing on Credo AI's own page claims Agent Governor already answers that operational question in general availability; the page's own release label says the opposite. That is not a criticism of the roadmap, a registry and a policy engine are a different kind of control than a per-ticket approval log, it is a reason not to expect one tool, in its current generally available state, to cover both. The "State of AI Governance 2026" report Credo AI links from its own homepage is itself framed around governance maturity across an organization's AI portfolio, the same portfolio-level lens the Policy Engine and AI Registry apply; nothing in the materials linked from the homepage claims that lens already extends to ticket-level agent operations, which is consistent with Agent Governor's preview label rather than contradicting it. #### Where each tool's generally available features sit The table below separates what each vendor's own site marks as generally available from what is still a preview or absent, rather than comparing roadmaps against each other. | Capability | Credo AI (GA today) | Atipol (GA today) | | Cross-framework policy packs (EU AI Act, NIST AI RMF, ISO 42001) | Yes, under the Policy Engine | Not offered; Atipol does not publish compliance policy packs | | Inventory of agents, models, applications, workflows | Yes, AI Registry with Agent Registry and Agent Cards | Agent inventory scoped to declared agents, each under an agent lead | | Agentic risk scoring and dedicated agent governance | Agent Governor: Research Preview, not GA | Role-based tool permissions and per-call approval: GA today | | Ticket-level acceptance criteria and review before merge | Not described on the page | GA today, documented in Atipol's governance guide | | Per-call audit log linking agent, ticket, and result | Not described on the page | GA today | | Public self-serve pricing | Not listed; sales-led | Free, Pro at 19 €/user/month, Business at 39 €, Enterprise by quote | #### What Atipol covers for day-to-day agent operations Atipol covers the layer Credo AI's page does not claim to cover yet: each agent is declared under one person's agent lead, which never holds more rights than that person, and every tool a declared agent can call is set to one of three states, allowed, subject to approval, or denied, rather than one blanket permission for the whole agent. Each call is logged and linked to the agent, the ticket it was working on, and the result, with any approval granted or denied, and review before a delivery merges has to come from someone other than whoever requested the work. Pricing is public and self-serve: Free, Pro at 19 euros per user per month including tax, Business at 39 euros, Enterprise by quote. None of these controls require a separate compliance framework to be useful; they apply the same way whether or not an organization also runs a tool like Credo AI's Policy Engine, which is why pairing the two does not mean paying twice for the same control. In numbers, Atipol's governance model today: - 19 € Pro plan, per user/month - 39 € Business plan - 3 tool permission states per agent #### Where the two are complementary, not competing A DSI reporting to a board or a regulator on AI risk across an entire portfolio, models, vendors, agents, and the applications built on them, is asking a question Credo AI's Policy Engine and AI Registry are built to answer, with evidence packs already mapped to the EU AI Act, NIST AI RMF, and ISO 42001. The same DSI asked, for one specific agent that merged a change into production last week, who approved it and what the agent actually did, is asking the question Atipol's ticket, permission, and audit-log model answers. Nothing about running Credo AI for portfolio-level compliance evidence prevents also running Atipol's governance layer on the agents themselves, and nothing in either vendor's documentation claims the other's capability as its own. In practice this plays out as two different documents landing on two different desks: a compliance officer pulling a Credo AI evidence pack mapped to the EU AI Act for a regulator, and an engineering lead pulling an Atipol ticket history to answer an incident review about one agent's merge last Tuesday. Neither document substitutes for the other, and neither vendor's page claims it does. #### When Credo AI alone might already be enough A team whose real, current need is producing audit-ready evidence against named regulatory frameworks across a large inventory of AI systems, most of them models and applications rather than autonomous agents taking actions in production, gets real value from Credo AI's Policy Engine and AI Registry today, without waiting on Agent Governor to leave preview. The gap only becomes operationally urgent once agents are the thing taking actions, not just the thing being inventoried, which is the point at which a ticket, a named reviewer, and a per-call log stop being optional and start being the actual evidence a DSI needs to produce. #### Building the comparison into a decision The ticket, permission, and audit-log model described above, and how it avoids repeating the same control twice when a model-level compliance tool already covers part of the picture, is laid out in full at atipol.ai/agentic-ai-blog/ai-agent-governance. How the same agents fit into GDPR and AI Act obligations specifically is covered at atipol.ai/agentic-ai-blog/agentic-ai-gdpr-ai-act, and the full, regularly reviewed comparison across governance tools is kept at atipol.ai/comparison. Q: Does Credo AI govern AI agents, or only models? A: Credo AI's own site states it covers agents, models, applications, and workflows through its AI Registry, with an Agent Registry and Agent Cards, and describes Agent Governance as a registry and risk controls for every agent. Its dedicated Agent Governor feature, however, is marked Research Preview rather than generally available. Q: Is Credo AI's Agent Governor generally available? A: No. Credo AI's own page labels Agent Governor as Research Preview, while describing GAIA, its core platform, as generally available in the platform today. The two labels apply to different parts of the product. Q: Can Credo AI and Atipol be used together? A: Yes, for different parts of the problem. Credo AI's Policy Engine and AI Registry produce compliance evidence mapped to frameworks such as the EU AI Act, NIST AI RMF, and ISO 42001 across a portfolio of AI systems. Atipol's ticket, permission, and audit-log model governs what a specific agent is allowed to do and who approved it, day to day. Sources: - Credo AI, credo.ai, accessed 11/11/2026: https://www.credo.ai/ - NIST, AI Risk Management Framework (AI RMF 1.0), published 26/01/2023: https://www.nist.gov/itl/ai-risk-management-framework - European Commission, AI Act regulatory framework, updated 19/10/2026: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai ### Dust vs Copilot Studio vs Atipol: Pricing, SSO, Logs Source: https://atipol.ai/blog/dust-vs-copilot-studio-vs-atipol Author: Younes Azabar, founder of ETCSEC Read only each vendor's own documentation, not its marketing page, and Dust, Copilot Studio, and Atipol turn out to solve three different shapes of the same governance problem: a hosted workspace, a Microsoft 365 control plane, and a cross-client ticket and audit layer. Entry price, SSO, and audit logging sit at different tiers for each one, which is exactly where the comparison below starts. #### Three tools, three different shapes of the same problem A PME comparing Dust, Microsoft Copilot Studio, and Atipol to govern its AI agents usually gets three vendor pages that each describe a different product shape as if it were the obvious default. Dust is a hosted workspace where a team builds agents against connected company data and chat clients. Copilot Studio is Microsoft's agent builder and governance layer for anything that lives inside Microsoft 365. Atipol is a governance layer for agents working across whichever MCP client a team already uses, Claude Code, Codex, Cursor, or others, rather than a workspace that hosts the agents itself. These three governance shapes break down as follows: | | Dust | Copilot Studio | Atipol | | Entry price | 24 €/seat/month (Pro, billed yearly) | $30/user/month (M365 Copilot add-on) | 19 €/user/month (Pro, including tax) | | SSO | Included from the Business plan | Via Microsoft Entra, included | Planned for Enterprise, not yet available | | Audit log | Enterprise plan only | Purview audit logs, Sentinel monitoring | Every call logged to agent, ticket, result | | Where agents run | Dust's own hosted workspace and connectors | Power Platform environments, Microsoft 365 channels | Any MCP client: Claude Code, Codex, Cursor, others | None of that difference shows up clearly from reading one vendor's pricing page against another's feature list, since each page is written to make its own shape look complete. What follows uses only each vendor's own documentation, dated, to describe what each one actually governs, what it costs at each tier, and where a team's actual agents decide which shape fits. #### What Dust documents Dust's own pricing page, verified 11 November 2026, describes one plan named Business, for teams up to 100 people, with Free, Pro, and Max as seat types inside it: Free gives 500 credits for the lifetime of the seat, Pro gives 8,000 credits per seat per month at 24 euros billed yearly or 30 euros billed monthly, and Max gives 40,000 credits per seat per month at 120 euros billed yearly or 150 euros billed monthly. A separate Enterprise plan, reached only through sales, adds workspace-pooled credits and volume pricing instead of per-seat credit caps. Governance features are split the same way the page splits plans. Single sign-on with Okta, Microsoft Entra ID, or JumpCloud is listed under the Business plan. SCIM provisioning, audit logs, custom data retention, and custom legal terms such as a tailored MSA or DPA are listed only under Enterprise. US and EU data residency is listed under Business, and Enterprise repeats it alongside single-tenant deployment, a stronger isolation guarantee than the shared Business plan offers. None of this is unusual for a per-seat SaaS pricing structure; it is the same pattern Microsoft applies to Copilot Studio and Atipol applies to its own plans, where the entry tier buys access and a higher tier buys the audit and compliance features. What changes between vendors is exactly where that line sits, which is why reading the line rather than the plan name is what actually tells a PME what a given monthly price includes. #### What Copilot Studio documents Copilot Studio's own documentation, covered in more detail in a separate comparison on this blog, governs agents built inside Microsoft 365 through data policies configured in the Power Platform admin center, updated 22 October 2026: enforced in real time since early 2025, these policies can require Microsoft Entra authentication, block connectors, HTTP requests, Azure Bot Service skills, specific publishing channels, and event triggers. Microsoft Agent 365, documented 5 November 2026, adds a control plane that represents Copilot Studio agents as Entra identities with Conditional Access and role-based access controls, with maker audit logs in Microsoft Purview and monitoring through Microsoft Sentinel. Pricing starts at 30 US dollars per user per month for the Microsoft 365 Copilot add-on, which covers internal use; publishing to external channels or letting unlicensed users interact with an agent requires a standalone Copilot Studio license billed through 25,000-credit capacity packs at 200 US dollars per month. #### What Atipol documents Atipol works as a governance layer rather than a hosting workspace: each agent is declared under one person's agent lead, which never holds more rights than that person, and each tool a declared agent can call carries one of three states, allowed, subject to approval, or denied, set tool by tool rather than as one blanket grant per agent. Every call an agent makes is logged and linked to that agent, the ticket it was working on, and the result, along with any approval granted or denied, which is the audit record a DSI or a PME owner pulls up when asked what an agent did. Pricing runs Free, Pro at 19 euros per user per month including tax, Business at 39 euros, and Enterprise by quote; Atipol does not detect shadow AI on its own, single sign-on with SAML or OIDC is planned for Enterprise rather than available today, and self-hosting is planned rather than shipped. #### Three vendors, the same dimensions The table below applies the same six questions to each vendor's own documentation; a blank or a qualifier means the page itself did not make a stronger claim, not that the feature is assumed absent. | Dimension | Dust | Copilot Studio | Atipol | | Entry price | 24 €/seat/month (Pro, billed yearly) | $30/user/month (M365 Copilot add-on) | 19 €/user/month (Pro, including tax) | | SSO | Included from the Business plan | Via Microsoft Entra, included | Planned for Enterprise, not yet available | | Audit log / SCIM | Enterprise plan only | Purview audit logs, Sentinel monitoring | Every call logged to agent, ticket, result | | Data residency | US or EU (Business); single-tenant (Enterprise) | Within Microsoft's own geographic availability | Per-organization encryption, hardware master key | | Where agents run | Dust's own hosted workspace and connectors | Power Platform environments, Microsoft 365 channels | Any MCP client: Claude Code, Codex, Cursor, others | | Self-hosting | Not offered | Not applicable (Microsoft-hosted service) | Planned, not yet available | #### Sovereignty: what the residency claims do and do not mean Residency claims are easy to state and easy to misread. Copilot Studio is entirely a Microsoft service, so its geographic options follow Microsoft's own documented availability regions; there is no separate vendor layer to evaluate. Dust states US and EU data residency under its Business plan without naming the underlying cloud infrastructure on its pricing page, which leaves that detail to Dust's own separate documentation rather than something this comparison can confirm from the pricing page alone. Atipol encrypts your data per organization, under a hardware master key; every access is checked against your rights and logged. Keeping a key, and the data it protects, inside a named EU region is a real control, but it does not make that data immune to a request made under a law that reaches the cloud provider operating the infrastructure, regardless of the region the data physically sits in. A PME evaluating any of these three tools on sovereignty should ask the same question of all three: which company actually operates the infrastructure holding the key, not only which region the page names. This is not a criticism specific to any one vendor; it is a property of relying on a major cloud provider's infrastructure at all, which every vendor compared here does in some form. The honest answer for a PME is not to expect immunity from any of the three, but to know, for each one, exactly which company holds the key before deciding how much weight the region name alone should carry. #### When each is the right choice A team already inside Microsoft 365, publishing agents to Teams or SharePoint, with Entra and Purview already in place for everything else, gets the most out of Copilot Studio without adding a second governance system, the same conclusion this blog's dedicated Copilot Studio comparison reaches in more detail. A team under 100 people that wants a single hosted workspace connecting chat, documents, and a shared set of agents, without standing up its own governance layer across multiple clients, fits the shape Dust's Business plan describes, with the understanding that audit logs, SCIM, and custom legal terms sit behind the separate Enterprise plan rather than inside Business. A team running agents across more than one client, a coding agent in one tool, a support agent in another, with tickets, acceptance criteria, and an audit log that has to look the same regardless of which client ran the agent, is the shape Atipol describes, and the one neither Dust's hosted workspace nor Copilot Studio's Microsoft 365 boundary was built to cover on its own. None of these three conclusions is permanent; a team that starts inside Microsoft 365 and later adds a non-Microsoft coding agent, or a team that outgrows Dust's 100-person Business plan, moves the right answer along with it, which is why the dimension that changed, not the vendor name, is what should trigger re-evaluating the choice. #### Building the comparison into a decision The permission model and audit log behind Atipol's numbers above, including how an MCP server gets reviewed before an agent connects to it, are covered at atipol.ai/agentic-ai-blog/mcp-security. How that model's per-user pricing translates into a cost per accepted delivery, the number that actually matters once agents are running in production, is covered at atipol.ai/agentic-ai-blog/ai-agent-costs, and the full comparison across all three tools, kept current, is at atipol.ai/comparison. Q: What is the main structural difference between Dust, Copilot Studio, and Atipol? A: Dust is a hosted workspace where a team builds and runs agents against connected data and chat clients. Copilot Studio is Microsoft's own agent builder and governance layer for Microsoft 365. Atipol is a governance layer for agents that already run in whichever MCP client a team uses, rather than a workspace that hosts the agents itself. Q: Which plan do I need for audit logs and SCIM with Dust or Copilot Studio? A: Dust's own pricing page lists SCIM provisioning, audit logs, and custom data retention only under its Enterprise plan, not under the Free, Pro, or Max seat types inside the Business plan. Copilot Studio's audit logging, through Microsoft Purview and Microsoft Sentinel, is documented as part of its standard security and governance controls rather than gated to a separate tier. Q: Does keeping encryption keys in a named EU region make agent data immune to foreign law? A: No. Atipol encrypts your data per organization under a hardware master key, with every access checked and logged; keeping a key in a named EU region is a real control, but it does not make the data immune to a legal request that reaches the company operating that infrastructure, regardless of the region named. Sources: - Dust, Pricing, accessed 11/11/2026: https://dust.tt/home/pricing - Microsoft, Microsoft 365 Copilot pricing (Copilot Studio), accessed 11/11/2026: https://www.microsoft.com/en-us/microsoft-365-copilot/pricing/copilot-studio - Microsoft Learn, Configure data policies for agents (Copilot Studio), updated 22/10/2026: https://learn.microsoft.com/en-us/microsoft-copilot-studio/admin-data-loss-prevention - Microsoft Learn, Security and governance (Copilot Studio), updated 05/11/2026: https://learn.microsoft.com/en-us/microsoft-copilot-studio/security-and-governance ### Copilot Studio Alternative: When It's Not Enough Source: https://atipol.ai/blog/copilot-studio-alternative-ai-agent-governance Author: Younes Azabar, founder of ETCSEC Before picking a Copilot Studio alternative, check one boundary: does your agent ever touch a Power Platform environment? If not, none of Copilot Studio's data policies, Agent 365 identity, or Purview audit logs apply to it. For agents built in Claude Code, Codex, or a non-Microsoft MCP server, the same acceptance-criteria, approval, and audit discipline has to come from elsewhere. #### Copilot Studio is not the wrong tool; it is a Microsoft 365 tool A DSI evaluating Microsoft Copilot Studio for AI agent governance is usually right that it covers a real need: agents built inside Microsoft 365 get a documented set of admin controls, tied to the same Microsoft Entra identity and Power Platform admin center the organization probably already uses for everything else. The question that actually needs an answer is narrower: what happens to the agents that do not live inside Microsoft 365, the ones built with Claude Code, Codex, Cursor, or a custom MCP client against systems Copilot Studio was never meant to reach. Copilot Studio's own documentation answers that question by scope, not by gap: its security and governance page describes data policies, Microsoft Agent 365 as a control plane, audit logs in Purview and Sentinel, and customer-managed encryption keys, all built around Power Platform environments and Microsoft Entra identities. None of that extends to an agent that never touches a Power Platform environment, which is not a flaw in Copilot Studio, it is a boundary. The practical question for a DSI is where that boundary sits relative to the agents actually running in the organization, and what covers the ones on the other side of it, since governance that stops at Microsoft 365 is not governance for a fleet of agents that does not. #### What Copilot Studio actually governs, with sources Microsoft's own documentation, updated 22 October 2026, describes data policies configured in the Power Platform admin center by a tenant admin or an Environment Admin, enforced in real time since early 2025 with no exemptions left standing. These policies can require Microsoft Entra authentication before an agent is published, block Power Platform connectors from being used as tools, block raw HTTP requests or filter them by endpoint, block Azure Bot Service skills, block publishing to specific channels such as Microsoft Teams, SharePoint, WhatsApp, or Facebook, and block event triggers that let an agent react without a prompt. The same documentation, updated 5 November 2026, adds Microsoft Agent 365 as a control plane that represents Copilot Studio agents as identities in Microsoft Entra, governed with Conditional Access, role-based and attribute-based access controls, and Entra network egress and ingress controls. Maker audit logs are visible to admins in Microsoft Purview, and agent activity can be monitored and alerted on through Microsoft Sentinel. Organizations can also enable customer-managed encryption keys for their Copilot Studio environments. One detail in the data-policy documentation matters specifically for teams that also use MCP: blocking a Power Platform connector in a data policy also blocks access to tools in any MCP server that relies on that connector for connectivity, which means Copilot Studio's governance does reach some MCP usage, but only the usage routed back through a Power Platform connector in the first place. This is a documented admin capability, not a claim about every possible Copilot Studio deployment: the same page notes that content moderation covers predefined harmful-content categories, but does not provide a tenant-configurable policy to block conversations on arbitrary administrator-defined topics, which is a narrower scope than a blanket content-governance claim would suggest. #### Copilot Studio next to a multi-client agent fleet The rows below compare what each side's own documentation says it governs, not a marketing claim against another; where Copilot Studio's page does not address a row, that is stated rather than filled in. | | Copilot Studio (Microsoft, dated) | A multi-client agent fleet | | Where agents can run | Power Platform environments, published to Teams, SharePoint, WhatsApp, Facebook, or Direct Line channels | Any MCP client: Claude Code, Codex, Cursor, the Claude app, ChatGPT, among others | | Who an agent acts as | Represented as a Microsoft Entra identity via Agent 365, governed with Conditional Access and RBAC/ABAC | One agent lead per person, which never has more rights than that person | | Tool and connector permissions | Data policies block or allow Power Platform connectors, HTTP, skills, triggers, by environment or tenant | Permissions set tool by tool, allowed, approval, or denied, per agent | | Audit trail | Maker audit logs in Microsoft Purview; activity monitored in Microsoft Sentinel | Each call logged and linked to an agent, a ticket, and a result, with approvals granted or denied | | Encryption | Customer-managed encryption keys available for Copilot Studio environments | Per-organization encryption, hardware master key, access checked against rights | | Entry cost | $30/user/month add-on; $200/month per 25,000-credit pack for broader use | 19 €/user/month (Pro), including tax | #### Where Copilot Studio's governance reaches its boundary Two gaps are worth naming because Microsoft's own documentation names them first. Customer Lockbox, the control that requires Microsoft approval before an engineer can access customer data, explicitly does not cover Copilot Studio's own security audit logging or Agent 365's governance and audit events, both of which the documentation says flow through separate pipelines outside Lockbox's reach. An organization relying on Lockbox as its data-access control should not assume it extends to the records that prove what an agent did. The second gap is the one already in the pain this article opened with: everything above governs agents built, published, and run inside Power Platform environments. An engineering team running agents through Claude Code or Codex against a Git repository, or a security team running an agent against a SIEM through its own MCP server, is outside that scope unless the connection happens to route through a Power Platform connector a data policy already covers. Neither gap is unique to Microsoft; any platform's audit pipeline has a boundary somewhere. The point for a DSI evaluating Copilot Studio is to ask the same question of whichever tool governs the agents outside Microsoft 365: which events are actually covered by the access control the organization relies on, and which ones live in a separate pipeline nobody checked. #### When Copilot Studio remains the right choice None of this is an argument against Copilot Studio where its own scope matches the problem. A team whose agents are built to answer employees inside Teams, pull from SharePoint, or extend Dynamics 365 Customer Service through Omnichannel is building exactly what Copilot Studio is for, and gets Entra-based identity, Purview audit logs, and Sentinel alerting for that work without adding a second governance system. An organization that has already standardized on the Power Platform admin center for every other Microsoft 365 workload gains little from running agent governance through a separate tool for the subset of agents that happen to live there too. The honest answer for that team is to keep using Copilot Studio's own data policies and Agent 365, and to add a second system only for the agents that fall outside Power Platform entirely. #### When the fleet needs governance that starts outside Microsoft 365 The gap shows up as soon as an organization runs agents through more than one client, against systems Power Platform connectors were not built to reach: a coding agent working directly in a Git repository, a security agent calling an internal API with no Power Platform connector, or a support agent built on a framework that has nothing to do with Microsoft 365. None of Copilot Studio's data policies apply to that agent, because the agent never touches a Power Platform environment in the first place. That is the scope a tool built around tickets with written acceptance criteria, review by someone other than the requester, and tool-by-tool approval independent of which client the agent runs in covers instead, applying the same discipline regardless of whether the agent is working in Claude Code, Codex, Cursor, or a Power Platform environment Copilot Studio already governs on its own. #### Pricing, compared on the same terms Microsoft's own pricing page, verified 11 November 2026, lists the Microsoft 365 Copilot add-on at $30 per user per month, which includes the Copilot Chat and Standard harnesses for building and using internal agents at no extra licensing cost. Publishing an agent to an external channel, using the GitHub Copilot harness, or letting unlicensed users interact with an agent requires a standalone Copilot Studio license, billed either through 25,000-credit capacity packs at $200 per month or a pay-as-you-go credit meter, both requiring an Azure subscription. A multi-client agent fleet priced per user rather than per credit, such as a Pro plan at 19 euros per user per month including tax, is a different cost model entirely, not a cheaper version of the same one; comparing the two means comparing what each unit of spend actually covers, not only the number next to the currency sign. #### Building the comparison into a decision The governance model this blog has already described, agent inventory, written acceptance criteria, role-based tool permissions, and an audit log tied to a ticket, applies the same way regardless of which client runs the agent, at atipol.ai/agentic-ai-blog/ai-agent-governance. The per-user, per-month cost model behind that approach, tracked in tokens and money by run, ticket, and project, is covered at atipol.ai/agentic-ai-blog/ai-agent-costs, and the full comparison against Copilot Studio and other tools on the same terms is kept current at atipol.ai/comparison. Q: Does Microsoft Copilot Studio govern AI agents that run outside Microsoft 365? A: No. Its documented data policies, Microsoft Agent 365 control plane, and audit logging all apply to agents built and published inside Power Platform environments. An agent running in a different client, such as Claude Code or Codex, against a system without a Power Platform connector is outside that scope. Q: What does a Microsoft 365 Copilot license include for building agents, and what costs extra? A: The $30 per user per month Microsoft 365 Copilot add-on includes the Copilot Chat and Standard harnesses for internal agent use at no extra cost. Publishing to external channels, using the GitHub Copilot harness, or allowing unlicensed users to interact with an agent requires a standalone Copilot Studio license, billed through 25,000-credit capacity packs at $200 per month or pay-as-you-go credits. Q: Does Customer Lockbox cover the logs that prove what a Copilot Studio agent did? A: No, not entirely. Microsoft's own documentation states that Copilot Studio's security audit logging and Microsoft Agent 365's governance and audit events are processed through separate pipelines and are excluded from Customer Lockbox coverage. Sources: - Microsoft, Microsoft 365 Copilot pricing (Copilot Studio), accessed 11/11/2026: https://www.microsoft.com/en-us/microsoft-365-copilot/pricing/copilot-studio - Microsoft Learn, Configure data policies for agents (Copilot Studio), updated 22/10/2026: https://learn.microsoft.com/en-us/microsoft-copilot-studio/admin-data-loss-prevention - Microsoft Learn, Security and governance (Copilot Studio), updated 05/11/2026: https://learn.microsoft.com/en-us/microsoft-copilot-studio/security-and-governance ### How to Stop Shadow AI Without Banning AI Agents Source: https://atipol.ai/blog/shadow-ai-agents-framework-instead-of-ban Author: Younes Azabar, founder of ETCSEC Shadow AI is not a detection problem: no platform, including Atipol, finds every unmanaged agent on its own, so the fix has to make the declared path faster than the undeclared one. That means a catalog of approved MCP servers, permissions set tool by tool, and administrator-logged exceptions for anything outside the catalog, applied the same way to every declared agent. #### Banning AI agents does not survive contact with a deadline A DSI who issues a blanket ban on connecting AI agents to company systems is solving the easy half of the problem. Banning does not stop a team under deadline pressure from wiring an agent into a spreadsheet, a ticket queue, or a customer database over a weekend, the same way banning unapproved SaaS tools never stopped shadow IT; it only guarantees that when it happens, nobody told the DSI first. The pain is not that agents exist outside the plan, it is that there is no framework to hand a team the moment they ask how to do this properly instead of quietly. The instinct that follows a ban failing is to look for a tool that finds every unmanaged agent and MCP server already running, the network-scanning equivalent of shadow IT discovery. That instinct runs into a harder limit than policy: an agent is a process a developer can start from a laptop with a single command, often talking to a service over a protocol built to be lightweight and easy to stand up, which is a much smaller footprint to hide than a SaaS subscription with an invoice trail. Treating every agent the same way, whether it drafts a status update or touches customer records, wastes the same effort a blanket ban wastes: it either blocks harmless automation outright, pushing it underground, or it waves everything through because enforcing a ban case by case is too slow, which leaves the agents that actually carry risk no more controlled than before the policy existed. #### No platform detects shadow AI on its own, including Atipol Atipol is explicit about this limit rather than quiet about it: it does not, on its own, detect MCP servers or agents installed outside the platform, and does not replace a separate discovery process for unmanaged tools. An agent that was never declared to Atipol, and never connects through it, leaves no event for Atipol to log, the same way a server a security team never onboarded leaves no event in that team's own monitoring. No platform, Atipol included, closes that gap by scanning for what was never pointed at it in the first place. This is not a reason to give up on governance, it is a reason to put the energy into the part of the problem a framework actually solves: making the declared, approved path fast and clearly better than the undeclared one, so fewer teams have a reason to go around it, and giving the teams that already have agents running a specific, low-friction way to bring them into view rather than leaving that decision to a ban nobody expects them to follow. OWASP's own guidance on Excessive Agency makes the same point from a different angle: reducing what an agent can do, minimizing its functionality, permissions, and autonomy, closes more of the gap a detection tool cannot, because a narrowly scoped agent has less to abuse even if it is never found. NIST's AI Risk Management Framework frames the same idea at the level of an entire organization, as a voluntary framework meant to help build trustworthiness considerations into the design and development of a system, not to scan for what was never declared to it after the fact. In one sentence: What a framework actually does: A framework does not find an undeclared agent; it makes the declared path fast enough, and the catalog visible enough, that fewer teams have a reason to skip it. No platform, including Atipol, closes the gap by scanning for what was never pointed at it. #### What a framework offers instead of detection The shape of that framework is a catalog rather than a scanner: Atipol relies on a catalog of servers allowed by the organization, set to one of three modes, open workspaces, catalog only, or mandatory approval, with the rule that a workspace can tighten the rules, never loosen them. Each person gets their own agent lead, which acts for that person and never has more rights than they do, so an agent's identity in the system is tied to a declared human from the moment it is created, rather than to an anonymous script nobody can trace back to a request. The catalog does not need to start by listing every tool a team might eventually want; it starts by listing what is already approved, with everything else routed to a specific, visible decision. "Off-catalog requests are decided by an administrator, and logged," which turns the question of a new, unlisted MCP server from a silent connection into a recorded request an administrator either grants or refuses. Put side by side, the two paths look like this: | | Undeclared agent | Declared agent (catalog) | | Visible to an administrator | No record exists | Logged at declaration | | Tool permissions | Whatever the process can reach | Set tool by tool | | Off-catalog request | No request to make | Decided and logged by an administrator | | Identity | Anonymous script | Tied to one person's agent lead | #### Shadow AI risk against the framework's response The Model Context Protocol's own security guidance names the specific risks an undeclared or poorly scoped agent connection creates; a declared catalog with tool-by-tool permissions answers each one directly rather than by trying to detect the connection itself. | Risk (MCP security guidance) | What it looks like unmanaged | Framework response | | Token passthrough | A server forwards a client's token to a downstream API without validating it was issued for that server | A catalog entry ties a server to a specific, reviewed configuration before any agent can use it | | Scope inflation | A token is granted broad scopes such as files:* or admin:* because that was easier than asking twice | Permissions are set tool by tool, allowed, approval, or denied, not as one blanket grant per agent | | Local server compromise | A locally run server executes with the same privileges as whoever started it, unsandboxed | Off-catalog servers are routed to an administrator decision before they run at all | | Confused deputy, consent skipped | A proxy server reuses a prior consent cookie to skip a new client's authorization screen | Every declared agent is tied to one person's agent lead, which never exceeds that person's own rights | | Undeclared connection | Nobody outside the team that started it knows the agent or server exists | A catalog-only or mandatory-approval workspace makes an undeclared connection fail to start rather than fail to be noticed | #### Build the catalog around least privilege, not blanket trust The Model Context Protocol's own security best practices describe the alternative to blanket trust as a progressive scope model: a "minimal initial scope set containing only low-risk discovery/read operations," with "incremental elevation via targeted... scope challenges when privileged operations are first attempted," rather than a server publishing, or a client requesting, every scope it might ever need up front. The specification is direct about the failure mode this avoids: "publishing all possible scopes," or "using wildcard or omnibus scopes (*, all, full-access)," expands what a single stolen token can reach and makes it harder to revoke access without disrupting every workflow that token touched. The same document's guidance on locally run servers applies the identical principle to the machine itself rather than to a token: a client should "execute MCP server commands in a sandboxed environment with minimal default privileges," launched "with restricted access to the file system, network, and other system resources," with explicit consent shown before a new local server runs at all. A catalog built around these two ideas, minimal scope by default and sandboxed local execution, gives a declared agent less to abuse even when a review misses something, which a detection tool aimed at the undeclared agent cannot do. The same guidance is specific about what that consent step has to show before a local server runs at all: the exact command that will be executed, without truncation, a clear identification that it is a potentially dangerous operation that executes code on the user's system, and explicit approval required before the configuration proceeds. Highlighting command patterns that touch a home directory, SSH keys, or system directories, and warning that a server runs with the same privileges as the client itself, turns a one-click install into a visible decision a person makes rather than something that happens silently in the background. #### Make the exception path visible instead of invisible An administrator who decides and logs every off-catalog request is not a detection system, but it produces something a detection system would also need: a record of who asked for what tool, when, and whether it was granted. That record exists because the decision was made inside the declared path, by a person routing a request through the catalog, not because a scanner found a connection after the fact. The honest version of this framework tells a team exactly that distinction up front, rather than letting them assume a catalog quietly watches for what they connect outside it. This also sets the right expectation for what happens when an undeclared agent is found some other way, through a vendor invoice, a network alert unrelated to Atipol, or a colleague mentioning it in a meeting. The catalog gives that agent somewhere to go once it is found: a category to request, a workspace mode that already applies to it, and an agent lead to assign it to, rather than a policy decision made from scratch each time one surfaces. This also keeps the exception auditable in the same vocabulary the Model Context Protocol's own guidance recommends for scope elevation: a specific, logged request met with a specific, logged decision, rather than a client silently assuming broader access because asking twice felt like friction. #### Giving the framework to the teams already running agents The three workspace modes move in one direction only: Diagram (flow) - Open workspace - Catalog only: Rules only tighten - Mandatory approval: Never loosens Open workspace -> Catalog only Catalog only -> Mandatory approval A declared-by-default rollout works better than a ban followed by a hunt. Moving a workspace from open to catalog only, then from catalog only to mandatory approval, matches the three modes the platform already supports, and matches the principle that rules only tighten, never loosen, so a team never experiences the framework as a surprise step backward in what they can already do. Each agent gets its own agent lead at declaration time, which ties identity and permission to a specific person from day one, the same structural choice the Model Context Protocol's own guidance makes when it recommends binding a session to a specific user rather than treating it as an anonymous credential. A short grace period for declaring agents already in use, paired with the same catalog and permission rules applied going forward, converts a backlog of undeclared automation into inventory without requiring anyone to admit to having broken a rule that, in practice, nobody could have followed in the first place. None of this requires finding every agent already running before starting; it requires making the declared path the one teams prefer, backed by the permission model, the catalog, and the logged exceptions described above, at atipol.ai/agentic-ai-blog/mcp-security and atipol.ai/agentic-ai-blog/ai-agent-governance, and the guided tour of that model at atipol.ai/security. Q: Can a platform detect shadow AI agents automatically? A: No platform does this reliably, including Atipol: it does not, on its own, detect MCP servers or agents installed outside the platform, and does not replace a separate discovery process for unmanaged tools. An agent that never connects through a platform leaves no event for that platform to log, which is why a catalog and permission model, rather than a detection claim, is the realistic response to shadow AI. Q: What should a catalog of approved MCP servers actually control? A: A catalog controls which servers an organization allows at all, set to one of three modes, open, catalog only, or mandatory approval, with permissions applied tool by tool rather than as one blanket grant per agent. The Model Context Protocol's own guidance adds that each server should start with a minimal scope and only request more through a specific, logged elevation, not a wildcard grant up front. Q: What happens when someone requests a tool outside the approved catalog? A: The request is decided and logged by an administrator rather than silently refused or silently allowed. That decision becomes part of the record precisely because it went through the declared path, which is the mechanism a framework offers in place of trying to detect a connection that bypassed the catalog entirely. Sources: - Model Context Protocol, Security Best Practices, version 2025-11-25, consultée le 11/11/2026: https://modelcontextprotocol.io/specification/2025-11-25/basic/security_best_practices - OWASP GenAI Security Project, LLM06:2025 Excessive Agency, consultée le 11/11/2026: https://genai.owasp.org/llmrisk/llm062025 - NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023: https://www.nist.gov/itl/ai-risk-management-framework ### AI Act Checklist for AI Agents: Articles 12 and 14 Source: https://atipol.ai/blog/ai-act-checklist-ai-agents-article-12-14 Author: Younes Azabar, founder of ETCSEC Before worrying about Article 12 logging or Article 14 human oversight, check one thing: does this AI agent's task fall inside one of the AI Act's eight Annex III areas? Only agents inside that scope face the two articles' specific legal obligations; map automatic event logging to Article 12 and a working stop-and-override mechanism to Article 14 for those agents, and keep the same controls as good practice for the rest. #### An AI agent is not automatically a high-risk AI system A DSI asked to show that the company's AI agents comply with the AI Act usually starts from the wrong question: which article applies to every agent. Most of the regulation's specific technical obligations, including Article 12 on record-keeping and Article 14 on human oversight, apply in full only to AI systems the regulation classifies as high-risk. An internal agent that drafts release notes or triages support tickets is not automatically in that category, and treating every agent as if it were invites either wasted compliance effort or, worse, a false sense that unrelated controls cover the real obligation. Article 6 of the AI Act sets two routes into high-risk status. The first covers AI systems that are themselves, or are a safety component of, a product already subject to third-party conformity assessment under EU harmonisation legislation listed in Annex I. The second is more relevant to most software teams: "AI systems referred to in Annex III shall be considered to be high-risk." An AI agent only enters this second route if the task it performs falls inside one of Annex III's listed areas, not because it is agentic, autonomous, or built on a large language model. Article 6(3) adds a filter even inside Annex III: a listed system is not high-risk if it does not pose a significant risk of harm to health, safety, or fundamental rights, for example because it performs a narrow procedural task or only improves the output of a completed human activity. That filter has its own hard limit: an Annex III system "shall always be considered to be high-risk where the AI system performs profiling of natural persons," with no narrow-task exception available. For a DSI building an inventory, the practical sequence is to list what each agent is actually used for, not what model or framework it runs on, check that use against the eight Annex III areas, apply the Article 6(3) filter and its profiling exception where a listed area is involved, and only then decide which of Article 12 and Article 14's specific requirements are a legal obligation for that agent rather than a voluntary good practice borrowed from the same two articles. The same four-step sequence is easier to follow as a diagram than as a paragraph: Diagram (flow) - List the agent's task: not the model or framework - Check Annex III: eight listed areas - Apply the 6(3) filter: profiling stays high-risk - Legal duty or good practice: Article 12 and Article 14 List the agent's task -> Check Annex III Check Annex III -> Apply the 6(3) filter Apply the 6(3) filter -> Legal duty or good practice The scope test, in one pass: List what the agent's task actually is, check it against the AI Act's eight Annex III areas, apply the Article 6(3) filter and its profiling exception, and only then treat Article 12 logging and Article 14 oversight as a legal requirement rather than good practice. #### Where an agentic workflow actually lands in Annex III Annex III lists eight areas, worded on the European Commission's AI Act Service Desk as: biometrics, where its use is permitted under relevant Union or national law; critical infrastructure; education and vocational training; employment, workers' management and access to self-employment; access to and enjoyment of essential private and public services and benefits; law enforcement, where permitted under relevant Union or national law; migration, asylum and border control management, where permitted under relevant Union or national law; and the administration of justice and democratic processes. An agent that triages internal support tickets, drafts marketing copy, or reviews a pull request does not fall inside any of these eight areas on the face of it. An agent that screens job applicants, scores a loan or benefit application, or feeds an output into a law-enforcement or border-control decision does, which is why the same question, which Annex III area, if any, does this agent's task fall into, has to be asked agent by agent rather than answered once for an entire fleet. Article 6(4) puts a paper trail on that judgment call: a provider that concludes an Annex III system is not high-risk must document that assessment before placing it on the market or putting it into service, which means the scope decision itself, not only the resulting controls, is something a DSI needs to be able to produce during an audit. The obligations split cleanly along that same boundary: | | Inside Annex III (high-risk) | Outside Annex III | | Article 12 automatic logging | Legal obligation | Good practice only | | Article 14 human oversight | Legal obligation | Good practice only | | Article 6(4) classification documentation | Required before market or service | Not required | #### Article 12 and Article 14, translated into agent controls Once an agent's task is confirmed to fall inside Annex III, or a team decides to apply the same discipline as good practice regardless, Article 12 and Article 14 translate into a short list of concrete controls rather than a block of legal text. None of these controls require guessing what regulators will accept later: each row maps to wording already published on the European Commission's own AI Act Service Desk, not to a generic security best practice relabelled for compliance, which is the difference between a control that holds up in an audit and one that merely sounds related to the article it is supposed to satisfy. | AI Act requirement | What it means for an agent | Control that satisfies it | | Automatic logging over the system's lifetime (Article 12) | Every tool call the agent makes needs a persistent, unprompted record | Each call is logged and linked to an agent, a ticket, and a result | | Logs traceable enough for risk and post-market monitoring (Article 12) | The log has to show who authorised an action, not only that it happened | The log records the explicit approval granted or denied for each call | | Effective human oversight while in use (Article 14(1)) | A person supervises the run, not only a summary afterward | Human approval is required before a specific call executes, not after | | Understand capabilities and limits, avoid over-reliance (Article 14(4)(a)(b)) | The overseer has to know what the agent can and cannot do, and not rubber-stamp its output | Review covers the actual output, never only the agent's own summary of it | | Override or disregard the output (Article 14(4)(d)) | A person can decide not to use the agent's result in a specific case | Each tool carries one of three states, allowed, approval, or denied | | Interrupt or halt the system (Article 14(4)(e)) | Someone has to be able to stop the agent mid-run, safely | A run can be stopped, its identity revoked, or a tool removed, without touching other agents | #### What falls outside Annex III still deserves the same discipline None of the reasoning above removes the operational case for logging and human review on agents outside Annex III. An agent that merges code, sends a customer message, or publishes content can still cause damage that a log would have made traceable and an approval gate would have stopped, independent of which legal article applies. The difference Article 6 draws is which controls are a binding obligation with a documented classification behind them, and which are a choice a team makes because the risk is real even where the regulation does not mandate the control. Article 14(4)(c) adds one more expectation for a high-risk system's overseer: being able to correctly interpret the system's output using the interpretation tools made available, which only works if the output a reviewer sees is the actual result of the call, not a paraphrase the agent wrote about its own work. This is also where a ticket-review discipline already described on this blog applies without any AI Act classification attached to it: a reviewer other than the requester checking the actual delivery, and a log of who approved what, is the same shape of control whether the agent in question ever touches an Annex III task or not. A log kept for an agent outside Annex III also keeps the classification decision honest over time. If a support agent is later given a feature that touches, say, access to an essential public service, the operational history already shows what the agent was doing before and after that change, which is the same kind of evidence Article 6(4) asks a provider to produce for an Annex III system judged not high-risk, applied here to a system that crossed into Annex III rather than one that started there. #### Calibrate what gets logged to the task, not a fixed template Article 12 does not fix one logging format for every system; it requires a level of traceability suited to the system's intended purpose. The one concrete minimum the regulation sets is narrower than agentic workflows in general: for remote biometric identification systems listed in Annex III, point 1(a), logs must at least capture the start and end time of each use, the database checked, the data that produced a match, and who verified the result. Most agentic workflows will need their own proportionate equivalent, not that specific list. That calibration cuts both ways. A support agent whose worst-case action is a poorly worded reply does not need the same logging depth as an agent feeding a decision into one of Annex III's eight areas, and treating every agent to the biometric-identification minimum would record detail the task never produced in the first place, without making the log any more useful for the risk the agent actually carries. #### Timing: when these obligations start to bite The strictest obligations do not apply immediately. The European Commission's own description of the AI Act lists 2 December 2027 as when the strict obligations for high-risk AI systems begin, which gives a DSI a planning horizon rather than an immediate deadline for Annex III systems identified today. Article 12 and Article 14 compliance for a newly classified agent is still worth building before that date, since retrofitting logging and an oversight interface into an agent already in production is slower than designing both in from the start. A classification done today is not necessarily permanent either: if an agent is redeployed into a new task area, or an existing task is extended into one of the eight Annex III areas, the Article 6 assessment has to be redone for that new use, not inherited from the agent's original, non-high-risk role. That December 2027 milestone sits inside a longer phase-in schedule for the whole AI Act: Charted, the same five milestones show how far apart the deadlines really sit: Chart (bar, months): Bans, AI literacy, GPAI models, General application, High risk, Annex III, High risk, Annex I - Months after entry into force: 6, 12, 24, 40, 48 Source: European Commission, AI Act regulatory framework, updated 19/10/2026 | Milestone | Applicable from | Months after entry into force | | Prohibited practices & AI literacy | 2 February 2025 | 6 | | GPAI models & governance rules | 2 August 2025 | 12 | | General applicability | 2 August 2026 | 24 | | High-risk systems, Annex III | 2 December 2027 | 40 | | High-risk systems, Annex I | 2 August 2028 | 48 | #### Building this into a compliance audit The classification memo required by Article 6(4), the per-call log Article 12 expects, and the human-approval record Article 14 implies are exactly the kind of evidence an auditor asks for months after the fact, not at the moment a system was built. Atipol's compliance-audit use case covers gathering that evidence with read-only agents, so a person reviews each control and the audit log itself records the human oversight behind that review, at atipol.ai/use-cases/compliance-audit. For the parts of an agent's compliance picture this checklist does not cover, how the GDPR and the AI Act interact across an agent's full lifecycle, or who pays when a general-purpose AI model itself turns out to be non-compliant, see atipol.ai/agentic-ai-blog/agentic-ai-gdpr-ai-act and atipol.ai/agentic-ai-blog/ai-act-sanctions-gpai. Keeping that evidence current matters as much as collecting it once: an agent's task, and with it its Annex III exposure, can change faster than an annual compliance review cycle, which is one more reason the log and the approval record described above need to run continuously rather than being reconstructed from memory when an auditor asks for them. Q: Does Article 12 of the AI Act require logging for every AI agent, or only high-risk ones? A: Only AI systems classified as high-risk under Article 6, mainly the eight areas listed in Annex III such as employment, essential services, or law enforcement, are legally required to meet Article 12's automatic-logging requirement. An agent whose task falls outside those areas can still log every call as good practice, the same way Article 12 is often implemented, but the article itself does not make that logging a legal obligation for that agent. Q: What must an AI agent's human overseer be able to do under Article 14? A: Article 14(4) lists five things an overseer must be able to do: understand the system's capabilities and limits, avoid over-relying on its output, correctly interpret that output using the tools made available, decide not to use the system or override its result in a specific situation, and interrupt or halt the system so it comes to a safe stop. Article 14(1) also requires the system itself to be built so a person can supervise it throughout its use, not only review it afterward. Q: If an AI agent is not high-risk under the AI Act, does a company still need to document that? A: Yes, for a system inside one of Annex III's eight areas that a provider judges not high-risk under the Article 6(3) filter: Article 6(4) requires documenting that assessment before the system is placed on the market or put into service. For an agent that never falls inside Annex III in the first place, the AI Act does not impose this specific documentation duty, though keeping a record of why an agent was judged out of scope is still useful evidence for an audit. Sources: - European Commission, AI Act Service Desk, Article 6, consolidated text as of 27/07/2026: https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-6 - European Commission, AI Act Service Desk, Annex III, accessed 11/11/2026: https://ai-act-service-desk.ec.europa.eu/en/ai-act/annex-3 - European Commission, AI Act Service Desk, Article 12, consolidated text as of 27/07/2026: https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-12 - European Commission, AI Act Service Desk, Article 14, consolidated text as of 27/07/2026: https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-14 - European Commission, AI Act regulatory framework, updated 19/10/2026: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai ### Where to Put Human Approval in AI Agent Workflows Source: https://atipol.ai/blog/human-in-the-loop-ai-agents-where-to-approve Author: Younes Azabar, founder of ETCSEC Put the human approval gate on high-impact AI agent actions only, enforced outside the agent itself, never inside a prompt it controls. Before deciding who approves what remains, shrink what the agent can do in the first place, then log who authorised each approved action, especially the ones that cannot be undone. #### Approving everything makes agents pointless; approving nothing is a liability A CTO rolling out AI agents usually lands on one of two failure modes. Require approval for every action and the agents stop saving any time, since someone still has to click through each step by hand. Require approval for none and a single bad tool call, a wrong file deleted, a message sent to the wrong customer, a merge that skips review, becomes the agent's problem to explain after the fact, not before. Neither extreme is a policy; both are an admission that nobody decided where the gate should sit. OWASP's GenAI Security Project names the underlying problem Excessive Agency: damaging actions performed in response to unexpected, ambiguous, or manipulated model output, rooted in excessive functionality, excessive permissions, or excessive autonomy granted to the agent. The fix OWASP describes is not a blanket approval screen in front of every action; it is reducing what can go wrong first, then gating only what is left. The two failure modes described above are not hypothetical for agents connected through MCP, the protocol most of these tools use to reach real systems. The same approval question, should this specific call wait for a person, comes up for every tool an agent can reach, not only for the agent's final output, which is why the answer has to be a rule applied tool by tool rather than a one-time decision made when the agent was first deployed. #### Shrink what needs approval before deciding who approves it OWASP lists minimizing extensions, minimizing extension functionality, avoiding open-ended extensions such as a general shell execution tool, minimizing extension permissions down to what the downstream system actually needs, such as read-only database access, and executing each extension in the specific user's own context with minimum privileges, as the first lines of defense against Excessive Agency. None of these involve a human clicking approve; they remove the action, the permission, or the blast radius before the question of approval ever comes up. A tool an agent cannot call does not need an approval gate, and a database connection with read-only rights cannot be the one that deletes a table, regardless of what any approval screen decides. Atipol applies the same ordering inside its own permission model: a sub-agent never has more permissions than the agent that delegated to it, so narrowing what the top-level agent can do narrows every sub-agent underneath it as well. Translated into an agent's actual configuration, this means an agent used for the ticket workflow this blog has already described gets a file-scope limit and nothing resembling a general-purpose shell tool, an agent that drafts customer replies gets a send function scoped to drafts rather than direct delivery, and an agent that touches a database gets exactly the columns and the read or write rights the task specifies, nothing broader granted for convenience. #### Put the gate on high-impact actions, enforced outside the agent Once unnecessary functionality, permissions, and autonomy are gone, OWASP's sixth mitigation addresses what is left: "Utilise human-in-the-loop control to require a human to approve high-impact actions before they are taken." The guidance adds that this control can sit downstream of the extension call or inside the extension itself, and pairs it with a seventh mitigation, complete mediation: enforcing authorization in the downstream system every time, rather than trusting the model's own judgment about whether an action is allowed. That second point matters operationally. An approval prompt that the agent itself decides whether to show is not a gate, since a manipulated or simply mistaken agent can skip the prompt the same way it would skip any other instruction. The decision to require approval, and the enforcement of that requirement, has to live in a system the agent does not control. OWASP also lists two measures that limit damage without preventing Excessive Agency in the first place: logging and monitoring extension activity, and rate-limiting undesirable actions. Both matter, but neither substitutes for the approval gate itself; a well-logged unauthorised deletion is still a deletion, and a rate limit slows repeated damage without stopping the first instance of it. #### Where teams actually put the gate Atipol's use cases show where different teams place that gate, action by action, rather than team by team. What the gate protects differs by domain, a customer relationship, an active incident, a codebase, a financial statement, but the shape of the gate is the same in every row: one person, other than whoever triggered the action, deciding before it takes effect, not reviewing it afterward. | Domain | Action gated | Who decides | Scope of the approval | | Customer support | Sending a reply to a customer | The person who approves the send | That specific message, once | | Security operations | Containing an incident | The analyst | That specific call, once | | Software development | Merging a pull request | A reviewer other than the requester | That specific call, before merge | | Observability | Opening a monitoring incident | The approver | That specific call | | Content publishing | Publishing to the CMS | The person approving through MCP | Routed through MCP approval | | Financial reporting | Signing off a report | The CEO or the CFO | That specific report | #### One call, one decision, never a blanket yes A gate that stays open after the first approval is not a gate. Atipol enforces the rule as a scope limit: human approval is given for one specific call, once, and each tool carries one of three permission states, allowed, subject to a person's approval, or denied, set tool by tool. When a tool is set to require approval, the call waits for a person's decision; if it is denied, the call is refused and logged rather than retried silently. The same model only tightens at larger scope, never loosens it: a workspace can move from open, to catalog only, to mandatory approval, but a workspace-level rule cannot be relaxed by an individual agent's configuration. A request outside the approved catalog is decided by an administrator and logged, which keeps the exception visible instead of letting it become a silent default. These three states apply the same way regardless of which team configured the agent: a support agent's send function, a SOC agent's containment action, and a finance agent's report submission each carry their own allowed, approval, or denied setting, rather than one approval setting applied to the whole agent. Changing a single tool's state does not touch any other tool the same agent can call. #### The reviewer is never the requester, and never the agent itself The same separation that applies to reviewing a ticket applies directly to approval gates: the person who asked for the work should not be the one who approves it. Atipol applies the rule without exception on either side of the request: no agent, human or artificial, approves its own delivery, and the human keeps the final decision on every approval. In practice this means an agent cannot generate a report and also sign it off, and a developer who assigned a ticket to an agent cannot be the required reviewer who approves the resulting change, the same constraint documented for GitHub's own coding agent pull requests. Role-based tool profiles extend this further: each role gets its own allowed-tool list, with explicit human approval required before any sensitive or irreversible action, rather than one blanket approver for the whole team. The same rule reaches sub-agents as well. Since a sub-agent never has more permissions than the agent that delegated to it, an approval requirement placed on the top-level agent's sensitive action cannot be bypassed by having a sub-agent perform the same action under a narrower task description; the permission ceiling, and the approval gate that comes with it, travels down the delegation chain. #### Approval without a record is not oversight An approval that is not written down is indistinguishable, six months later, from no approval at all. Atipol's audit log is specific about what it shows: who authorised an action, not only that it happened, and for an irreversible action such as publishing or deleting, the explicit human approval that came before it, recorded alongside the action itself. Regulators are moving in the same direction for systems they classify as high-risk. The European Commission's own description of the AI Act, last updated 19 October 2026, lists appropriate human oversight measures among the obligations that apply to high-risk AI systems, and states that once such a system reaches the market, deployers must ensure human oversight and monitoring through its use, not only at deployment. NIST's AI Risk Management Framework (AI RMF 1.0, published 26 January 2023) frames this at a higher level: it is meant to help organizations incorporate trustworthiness considerations into the design, development, use, and evaluation of AI systems, which includes who gets to approve what an agent does, not only what the agent produces. #### Building this into a team None of this requires deciding, action by action, from scratch. Start by removing functionality, permissions, and autonomy the agent does not need, following OWASP's first mitigations; set the tools that remain to one of three states, allowed, approval, or denied; name a reviewer for each gate who is never the requester and never the agent; and log who approved what, with irreversible actions carrying their approval alongside them in the record. The four steps above translate into a single, repeatable sequence: Diagram (flow) - Shrink agent scope - Gate high-impact calls - Independent reviewer - Log who approved Shrink agent scope -> Gate high-impact calls Gate high-impact calls -> Independent reviewer Independent reviewer -> Log who approved A useful test for whether the gate is in the right place: remove the approval step and ask what the worst outcome looks like. If the answer is a few minutes of rework, the action was probably never high-impact enough to need a human in the first place. If the answer is a wrong report signed off, a database table gone, or a message a customer should never have received, the gate belongs exactly where OWASP and Atipol put it: before the action, enforced outside the agent, and recorded afterward. The security practices behind that model, including per-agent tool allowlists, secrets kept out of prompts, and reviewing an MCP server before connecting it, are laid out at atipol.ai/agentic-ai-blog/mcp-security. The governance framework around roles, the usage policy, and where review has to sit before a merge is covered at atipol.ai/agentic-ai-blog/ai-agent-governance. To see these permission states, approval gates, and the audit log applied across a team of agents, the security section of the product at atipol.ai/security walks through setting a tool to allowed, approval, or denied, and what gets logged when a person approves or denies a call. Q: Which AI agent actions need human approval and which don't? A: OWASP's guidance on Excessive Agency points to high-impact actions, the ones where a wrong call is costly or hard to reverse, such as publishing, deleting, merging, or sending to a customer. Lower-impact actions are better handled by shrinking the agent's functionality, permissions, and autonomy so fewer of them exist in the first place, rather than by approving each one. Q: Can the agent or the person who requested the action approve it themselves? A: No. Atipol applies the rule that no agent, human or artificial, approves its own delivery, and that the person who asked for the work should not be the one who approves it, the same independent-review rule documented for GitHub's Copilot coding agent pull requests. Q: What should be logged when a human approves or denies an agent's action? A: The log should show who authorised the action, not only that it happened, and for an irreversible action such as publishing or deleting, the explicit approval that came before it, recorded alongside the action in the audit trail. Sources: - OWASP GenAI Security Project, LLM06:2025 Excessive Agency, consultée le 11/11/2026: https://genai.owasp.org/llmrisk/llm062025 - European Commission, AI Act regulatory framework, mise à jour 19/10/2026: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai - NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023: https://www.nist.gov/itl/ai-risk-management-framework ### How to Manage AI Agent Tickets: Criteria and Review Source: https://atipol.ai/blog/ai-agent-ticket-management-acceptance-criteria Author: Younes Azabar, founder of ETCSEC If the person who asked an AI agent for a pull request is also the one who approves it, that approval does not count: GitHub's own rules say so, and Atipol applies the same separation in its ticket flow. Every ticket also needs written acceptance criteria set before the agent starts, plus a logged, searchable decision history, so a delivery is checked against a target fixed in advance, not graded after the fact. #### Agents deliver fast, but nobody can say what was approved A CTO assigning work to AI agents usually gets a result quickly. The harder question comes after: what exactly was the agent asked to do, who checked the delivery against that request, and who signed off before it was merged or shipped. Without a ticket that records a target, a reviewer, and a decision, speed creates a trail that nobody can follow six weeks later when something breaks. This is a process gap, not a model quality problem. A fast agent that works from an unwritten brief and gets waved through by the same person who asked for it produces output just as quickly as one that works from a clear ticket. The difference only shows up during an incident review, an audit, or a disagreement about what was actually promised. That cost tends to surface at the worst possible time: during an incident postmortem, a security review, or a customer audit, when someone asks for the record of what an agent was asked to do and who approved it, and the honest answer is that no such record exists. NIST's AI Risk Management Framework (AI RMF 1.0, published 26 January 2023) frames this as a lifecycle concern rather than a one-off task: the framework is meant for voluntary use to help organizations incorporate trustworthiness considerations into the design, development, use, and evaluation of AI systems, not only into the output of a single agent run. #### Write the acceptance criteria before the agent starts, not after An acceptance criterion fixes, in writing, what a delivery must satisfy before the agent is launched. Setting the bar afterward, once the agent's own summary of its work is already on the table, invites grading the work against what was delivered rather than against what was asked. The rule here is plain: every ticket requires acceptance criteria written before the agent is launched, and a criterion the agent cannot meet should surface as a blocker before review, not during it. A second element travels with the criteria: the file scope. Reserving which files or areas a ticket may touch before the agent starts means two tickets in progress cannot claim the same scope, so an overlap between two agents is caught at handoff instead of discovered inside a merge conflict. In practice this means the criteria describe an outcome, not an implementation: which file or module the change applies to, what the diff must and must not touch, and the specific check that has to pass. A criterion the agent cannot satisfy is meant to surface as a blocker and go back to the requester before a reviewer ever opens the pull request, rather than being discovered during review once the work is already done. #### The life cycle of a ticket assigned to an AI agent GitHub's own documentation for its Copilot coding agent describes a concrete version of this life cycle. Once an issue is assigned to the agent, it acknowledges the assignment with a reaction, opens a dedicated branch and a draft pull request linked to the issue, and begins an agent session. While it works, it pushes commits and updates the pull request body with status messages. When it is done, it posts a finished-work event and requests a review, which is the signal that the ticket has moved from in-progress to awaiting a human decision. The same documentation adds a troubleshooting detail that matters operationally: sessions time out after one hour, and a stuck agent is recovered by unassigning and reassigning the issue or reposting the triggering comment, not by waiting indefinitely. GitHub's documentation describes several ways to put a ticket in front of the agent: assigning an issue from the Issues tab the same way you would assign it to a teammate, from GitHub Projects or GitHub Mobile, through the GraphQL API by checking that the coding agent appears as a suggested actor and then calling a mutation to assign it, or from the command line with the GitHub CLI. Whichever path is used, the agent only receives the issue's title, description, and the comments that existed at the time of assignment; comments added afterward are not seen by the agent, so later instructions have to go on the pull request itself, not back on the original issue. #### Stages at a glance The stages below generalize across tools that assign tickets to AI agents; the signal names differ by platform, but the sequence does not. Naming the signal at each stage matters more than it looks: a team that only knows an agent is assigned, with no visible signal for acknowledgement, in-progress work, or completion, ends up polling the agent instead of being told when a ticket needs attention. | Stage | Signal to watch | Who acts next | | Assignment | Agent acknowledges the ticket | Agent starts work inside its reserved scope | | In progress | Status updates and commits land on the ticket's branch | Team can comment to redirect before completion | | Finished work | Agent posts a completion event | A reviewer other than the requester is asked to look | | Review | Reviewer checks the diff against the acceptance criteria | Reviewer approves or sends it back with a blocker | | Integration | Checks are rerun at merge time | Decision and ticket are recorded in the history | #### The person who asked for the work should not be the one who approves it GitHub's documentation on reviewing a pull request created by Copilot states that if a repository requires pull request approvals, the approval of the person who assigned the issue to the agent does not count toward that required number; another reviewer has to approve it before merge. The related training material is more direct about why: the developer who asked Copilot to create the pull request cannot approve it, which preserves the repository's required-review rule and keeps an independent check in the loop. Atipol applies the same separation inside its own ticket flow: the project's agent lead reviews every delivery before integrating it, and that review is expected to cover the actual diff, not only the summary the agent gives of its own work. Integration then reruns the project's checks rather than relying solely on the review that preceded it, so a check that would have caught a problem is not skipped because a human already looked at the summary. This is not a Copilot-specific carve-out. GitHub's general documentation on required reviews states plainly that pull request authors cannot approve their own pull requests, and that when a ruleset or branch protection rule requires reviews, an approval has to come from someone other than the author before the change can merge. The same page adds two details specific to Copilot: approvals by Copilot itself appear in that reviewers panel but do not count toward the required number, and the person who assigned the related issue to Copilot cannot approve the pull request it raised, which closes the loophole of approving indirectly through the agent. The role separation from assignment to integration, as a diagram: Diagram (flow) - Requester: Assigns the ticket - Agent: Opens the pull request - Reviewer: Not the requester, approves - Integration: Reruns the checks Requester -> Agent Agent -> Reviewer Reviewer -> Integration #### Turning ticket decisions into a history someone can search later A reviewer's approval is only useful for as long as someone remembers it happened. Atipol keeps the history of every ticket and the review decisions that validated it, producing a record of who requested what and who approved what before an action was integrated. Each call an agent makes is linked to an agent, a ticket, and a result, together with any approval granted or denied, which turns a question raised weeks later into something a reviewer can search rather than something a reviewer has to remember. A log set up after an incident does not help establish what was actually read or written during it; the record has to exist before the agent is connected, not after something goes wrong. The reasoning for building that log before connecting an agent, rather than adding it after a problem surfaces, is the same one behind writing acceptance criteria before launch: a record assembled after the fact can describe what probably happened, but it cannot replace a line that ties a specific call to the agent that made it, the ticket it was working on, and the approval that was granted or denied at the time. #### When a platform's native flow is still the right choice Teams whose AI agent work happens entirely inside one GitHub repository, with a single coding agent and a branch-protection rule already in place, get the assignment, draft pull request, finished-work event, and independent-approval rule directly from GitHub, as described above, without adding another system. That native flow is enough when the acceptance criteria live in the issue description and one platform's review rules are the only ones that matter. The gap appears once a team runs more than one agent, or more than one tool, against a shared backlog: file scope has to be reserved across tools, acceptance criteria have to be visible to whichever agent picks up the ticket next, and the decision history has to cover agents that never touch GitHub's pull request flow at all. That coordination across tools and agents is what a ticket system built for AI agents, such as Atipol's, is meant to cover; see how several agents share tickets and file scope without colliding at atipol.ai/agentic-ai-blog/parallel-claude-code-agents. The same GitHub documentation lists the limits of that native flow on its own terms: the agent is not available on Enterprise Managed User personal repositories, so those have to move to an organization-owned repository with GitHub-hosted runners; a session that appears stuck can usually be recovered by unassigning and reassigning the issue rather than waiting it out, since sessions time out after one hour; and pull requests from the agent stay in draft and do not trigger GitHub Actions automatically, so a human still has to approve and run the workflow by hand. None of that changes once a second agent or a second tool joins the same backlog; it just means the native flow was never meant to coordinate more than one. #### Building the practice into a team None of this requires new tooling to start: a ticket with written acceptance criteria, a reviewer who did not request the work, and a record of the decision cover most of the gap described above. The governance framework behind that practice, including a sample usage policy and where human review has to sit before a merge, is laid out at atipol.ai/agentic-ai-blog/ai-agent-governance. A minimal version of this practice fits on one ticket: a written acceptance criterion, a named reviewer who was not the requester, and one line in a log recording the decision. Everything else described above, branch protection rules, API-driven assignment, a dedicated audit trail, is a way of enforcing that minimal version at a larger scale once more than one agent and more than one reviewer are involved. To see this ticket, review, and history flow applied end to end across a team of agents, the guided tour at atipol.ai/tour walks through assigning a ticket to an agent lead, setting acceptance criteria, and reviewing a delivery before it is integrated. Three things a ticket needs: Written acceptance criteria set before the agent starts, a reviewer who did not request the work, and a logged decision that exists before the agent is connected. Q: Who should write the acceptance criteria for an AI agent ticket? A: Whoever requests the work writes the criteria before the agent is launched, since the goal is a target the agent can be checked against, not a summary graded after delivery. Q: Can the agent that completed a ticket approve its own pull request? A: No. Per GitHub's documentation on Copilot coding agent and on required reviews generally, an approval from the person who assigned the issue does not count toward a repository's required reviews, and a different reviewer has to approve the change before merge. Q: What should an audit log for AI agent tickets record? A: Each entry should link an agent, a ticket, and a result, along with any approval granted or denied, and it needs to exist before the agent is connected so it can answer questions raised after the fact. Sources: - Microsoft Learn, Assigning, tracking, and troubleshooting Copilot in the cloud, mise à jour 27/10/2026: https://learn.microsoft.com/en-us/training/modules/github-copilot-code-agent/3-assign-track-troubleshoot-copilot-code-agent-tasks - GitHub Docs, Reviewing a pull request created by Copilot, consultée le 11/11/2026: https://docs.github.com/en/copilot/how-tos/agents/copilot-coding-agent/reviewing-a-pull-request-created-by-copilot - GitHub Docs, Approving a pull request with required reviews, consultée le 11/11/2026: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/reviewing-changes-in-pull-requests/approving-a-pull-request-with-required-reviews - NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023: https://www.nist.gov/itl/ai-risk-management-framework ### Agentic AI Governance Platform: How to Choose One Source: https://atipol.ai/blog/agentic-ai-governance-platform Author: Younes Azabar, founder of ETCSEC Before you sign with any agentic AI governance platform, ask it to show one agent's scope, owner, and recent action log: if it cannot, the rest of the comparison does not matter. Then check how it handles tool-level permissions, audit evidence, and encryption, and compare vendors against your own compliance requirements, including the EU AI Act and the NIST AI Risk Management Framework. #### What an agentic AI governance platform actually controls An agentic AI governance platform sits between your AI agents and the systems they touch. It defines which tools, repositories, or APIs each agent can reach, under which account, and with which limits. Instead of trusting a single broad credential, the platform assigns a scoped identity to every agent, so access can be granted, narrowed, or revoked without touching the underlying system. Most platforms built for agentic AI add a second layer: an audit log that records what each agent actually did, not just what it was allowed to do. Atipol, for example, keeps an audit log of key openings by the server and logs administrator decisions on requests for tools outside the approved catalog. That distinction, between permission and action, is what a governance platform is meant to close. A governance platform also names an owner for each agent. On Atipol, every person has their own agent lead, and that agent lead never holds more rights than the person it acts for. That rule matters for a DSI: it means an agent's access maps back to a real account, with a real owner, instead of a shared service credential nobody can trace. None of this is unique to one vendor. Any agentic AI governance platform you evaluate should be able to show, for a single agent, its scope, its owner, and a log of what it did recently. If a vendor cannot produce that trio on request, the rest of the comparison does not matter much. This is why the market groups under one label, agentic AI governance platform, even though the underlying problem, who can an agent act as, is closer to classic identity and access management than to a traditional AI tool. Ownership and action logging form one chain: Diagram (flow) - Named owner - Scoped agent lead - Verifiable action log Named owner -> Scoped agent lead Scoped agent lead -> Verifiable action log #### Why the decision reaches the DSI's desk now Two references explain why AI agent oversight is now a DSI decision rather than a side project. The EU's Artificial Intelligence Act, Regulation (EU) 2024/1689, sets risk-based obligations for AI systems used inside a company, including agentic ones. The NIST AI Risk Management Framework, AI RMF 1.0, published 26 January 2023, and its Generative AI Profile, NIST-AI-600-1, published 26 July 2024, describe the governance functions Govern, Map, Measure, and Manage. A platform should help an organization produce evidence for each function, not just a policy document. Agentic AI also changes the threat model inside a company. OWASP's Agentic AI, Threats and Mitigations, published 17 February 2025, catalogs failure modes specific to autonomous agents, such as excessive tool permissions and unsupervised actions chained together. A governance platform is one of the controls that document points to. The AI Act entered into force on 1 August 2024, and its obligations apply in phases counted from that date, including two high-risk deadlines that a 2026 amendment, the AI Omnibus, moved later than originally set. In months after entry into force: Chart (bar, months): Prohibited, literacy, GPAI, governance, General application, High-risk, Annex III, High-risk, Annex I - Months after entry into force: 6, 12, 24, 40, 48 Source: European Commission, AI Act regulatory framework, updated 19/10/2026 | Milestone | Applicable from | Months after entry into force | | Prohibited practices & AI literacy | 2 February 2025 | 6 | | GPAI models & governance rules | 2 August 2025 | 12 | | General applicability | 2 August 2026 | 24 | | High-risk systems, Annex III | 2 December 2027 | 40 | | High-risk systems, Annex I | 2 August 2028 | 48 | #### The five criteria that separate the offers Once the basics, identity, permissions, and logging, are in place, the real differences between agentic AI governance platforms show up in five areas, listed below. These are worth scoring vendor by vendor, with a primary source or a documented answer behind each score, not a sales slide. None of these five criteria requires trusting a vendor's claim on faith. Each one maps to a specific artifact, such as a settings page, a security document, or a support reply, that a DSI can ask for before signing anything. Score each criterion as available today, planned, or absent. - Agent identity and ownership: does every agent trace back to one named person? - Tool and action permissions: is access scoped per agent, instead of shared? - Audit evidence: is there a reviewable log of what an agent did, not just what it could do? - Encryption and key management: is the exact algorithm and key custody documented? - Identity and access control: does SSO with SAML or OIDC exist today, or is it only planned? #### A comparative grid to score any platform The grid below turns the five criteria into a working checklist. It uses Atipol as a worked example, since its documented facts are publicly checkable, but the same rows apply to any agentic AI governance platform you put side by side. Read any such grid as a snapshot, not a verdict. A vendor already self-hosted today, with SSO already live, can remain the better fit until a competitor's roadmap items actually ship. Re-check the roadmap column against the vendor's own documentation before a renewal, since roadmaps move. | Criterion | What to require | Atipol today | Atipol roadmap | | Agent identity and ownership | Every agent traces to one named human owner | One agent lead per person, which never exceeds that person's own rights | None noted | | Tool and action permissions | Scoped access per agent, not one shared credential | Off-catalog tool requests are decided and logged by an administrator | None noted | | Audit evidence | A reviewable log of what each agent did | Key openings by the server are recorded in the audit log | None noted | | Encryption and key management | Named algorithm and key custody, not a marketing label | Per-organization encryption, hardware master key; every access checked and logged | Customer-held key for Enterprise | | Identity and access (SSO) | SAML 2.0 or OIDC for workforce identity | Sign-in with Google or GitHub | Enterprise SSO with SAML or OIDC | | Hosting model | Match your data residency and control needs | Managed service; not open source | Self-hosted version | #### What Atipol provides today On encryption, your data is encrypted per organization, under a hardware master key; every access is checked against your rights and logged. Full detail sits at https://atipol.ai/security. On access, each person has their own agent lead, and that agent lead never holds more rights than the person it acts for. Agents run on Mac, Windows, a Linux binary, or a Docker runner, with a signed Mac app, a Windows app, and Linux binaries for amd64 and arm64 available for download today. Atipol is not open source. Sign-in today works with Google or GitHub; enterprise single sign-on is covered in the next section, since it is not yet available. None of this replaces reading a vendor's own security documentation before a decision. #### What is planned, not available yet Three capabilities sit on Atipol's roadmap rather than live today. Enterprise single sign-on with SAML 2.0 or OIDC is planned for the Enterprise plan. Self-hosting, described as a later, Enterprise-oriented capability, is planned, not available. A customer-held encryption key, kept in the customer's own vault and revocable, is also planned for Enterprise. On shadow AI, Atipol does not, on its own, detect MCP servers or agents installed outside the platform. Requests for tools outside the approved catalog are instead decided by an administrator and logged, which narrows exposure for agents already enrolled, but does not replace a separate discovery process for unmanaged tools. A DSI should treat each of these gaps as a timeline question, not a disqualifier: ask the vendor for a date, and weigh it against how urgent SSO, self-hosting, or a customer-held key actually are for the first stretch of use. Atipol's governance capabilities split cleanly between what already works today and what is only planned for the Enterprise plan. | | Available today | Planned (Enterprise) | | Agent lead scoped per person | Yes | No | | Sign-in with Google or GitHub | Yes | No | | Audit log of key openings and tool decisions | Yes | No | | Enterprise SSO (SAML 2.0 or OIDC) | No | Yes | | Self-hosted deployment | No | Yes | | Customer-held encryption key | No | Yes | The three-item test: Before scoring any agentic AI governance platform, ask it to show one agent's scope, its named owner, and a log of what it did recently. If it cannot produce that trio on request, the rest of the comparison does not matter much. #### Common mistakes when comparing these platforms The most common mistake is comparing marketing pages instead of primary sources. A security claim on a landing page is not the same as a security documentation page that names the exact algorithm, the key custody model, and the region where a master key sits. Ask for the latter before scoring any vendor on encryption. A second mistake is treating a roadmap item as if it were already shipped. Atipol separates what is available today, such as per-person agent leads and Google or GitHub sign-in, from what is planned, such as enterprise SSO, self-hosting, and a customer-held key. The same separation should apply to every vendor compared. A third mistake is skipping the audit log until after signing. Ask to see, during the evaluation, what a real log entry looks like for a tool call an agent made, not a sample screenshot. If a vendor cannot produce one on request, that is itself an answer about how mature the logging really is. #### How to run the evaluation inside your organization Start with an inventory, not a vendor call: list every AI agent already running against your systems today, who owns each one, and what it can reach. Most organizations find more agents than expected once API keys and MCP connections are counted properly. Map that inventory against the five criteria above, score each platform you consider, and run a short pilot with one team before a company-wide rollout. Require the audit log evidence in writing during the pilot, not after the contract is signed. Atipol covers agent scopes, tool permissions, and audit logs in more operational detail than a single comparison page can, at https://atipol.ai/agentic-ai-blog/ai-agent-governance, useful while building that checklist. Treat the whole exercise as a recurring check, not a one-time purchase decision. Agentic AI platforms update their roadmap regularly, so the SSO, self-hosting, and encryption rows in the grid are worth re-checking at each renewal. Once the checklist and the pilot both hold up, compare agentic AI governance platforms side by side, including Atipol, at https://atipol.ai/comparison, and keep the same five criteria for whichever vendor you choose. Q: What is an agentic AI governance platform? A: It is software that manages AI agents the way an IT team manages employee access: it assigns each agent a scoped identity, called an agent lead when tied to one person, limits which tools and systems it can reach, and keeps a log of what it actually did. The goal is to make an agent's access and its actions reviewable after the fact, not just bounded on paper by a policy document nobody checks. Q: Does a governance platform detect shadow AI on its own? A: Not necessarily, and that gap is worth checking before signing. Atipol, for example, does not on its own detect MCP servers or agents installed outside the platform. It instead lets an administrator decide on and log requests for tools outside the approved catalog, which narrows exposure but still depends on every agent being enrolled through the platform in the first place, not running around it unnoticed. Q: Is single sign-on available today? A: On Atipol, enterprise single sign-on with SAML 2.0 or OIDC is planned for the Enterprise plan, not available today. Sign-in with Google or GitHub is available now. A DSI that requires SAML or OIDC on day one should treat this as a roadmap item, ask the vendor for a committed date, and confirm that date again before any renewal decision. Sources: - NIST AI Risk Management Framework, AI RMF 1.0, 26/01/2023, and Generative AI Profile NIST-AI-600-1, 26/07/2024: https://www.nist.gov/itl/ai-risk-management-framework - OWASP, Agentic AI: Threats and Mitigations, 17/02/2025: https://genai.owasp.org/resource/agentic-ai-threats-and-mitigations/ - European Commission, Regulatory framework for AI, updated 19/10/2026: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai ### MCP Is Stable in Agent Framework 1.0. A2A Isn't. Source: https://atipol.ai/blog/microsoft-agent-framework-1-0-mcp Author: Younes Azabar, founder of ETCSEC Microsoft lists MCP as stabilized and backward-compatible in Agent Framework 1.0, released April 3, 2026, while full A2A 1.0 support is still coming soon with no committed date. For an IT services firm running agents across several clients, that gap matters before committing an integration to either protocol. #### What Microsoft Agent Framework 1.0 Actually Changed Microsoft published Agent Framework 1.0 on April 3, 2026, as a NuGet package named Microsoft.Agents.AI for .NET and a PyPI package named agent-framework for Python. The release follows a Release Candidate from February 2026 and the framework's original launch in October 2025. Microsoft describes 1.0 as a package version bump from the Release Candidate, not a rewrite. By November 6, 2026, the NuGet package had reached version 1.28.0. #### MCP Is Part of the Stabilized Core Microsoft lists MCP (Model Context Protocol) under "What's in version 1.0," stating that MCP lets agents dynamically discover and invoke external tools. 1.0 covers features Microsoft calls "battle-tested, stabilized, and committed to supporting with full backward compatibility." MCP sits inside that commitment, alongside single agents, multi-agent orchestration, agent memory, and YAML workflows. MCP's documentation describes it as a standard way to connect agents to external tools and data, like "a USB-C port for AI applications." #### A2A Support Is Not There Yet The same section of the announcement lists A2A (Agent2Agent) alongside MCP, but with a different status: "A2A 1.0 support coming soon." Microsoft does not give a date for that support. For a team planning cross-agent interoperability through A2A rather than MCP, the framework's 1.0 release does not yet carry the same backward-compatibility commitment. #### Stable vs. Preview in Version 1.0 Microsoft splits 1.0 into two tiers. The stable tier includes MCP, single agents, multi-agent orchestration patterns, agent memory, and YAML-based workflows, all covered by the backward-compatibility commitment. The preview tier includes DevUI, Foundry Hosted Agent Integration, AG-UI and ChatKit integrations, Skills, the GitHub Copilot SDK and Claude Code SDK integrations, and the Agent Harness, which can still change before their own 1.0. | Capability | Status in version 1.0 | | MCP (Model Context Protocol) | Stable, backward-compatible | | Single agents and connectors | Stable, backward-compatible | | Multi-agent orchestration (sequential, concurrent, handoff, group chat, Magentic-One) | Stable, backward-compatible | | Declarative YAML agents and workflows | Stable, backward-compatible | | A2A (Agent2Agent) | 1.0 support coming soon | | DevUI, Foundry Hosted Agent Integration, Skills, Agent Harness | Preview, can still change | #### Why This Matters for ESNs Managing Multiple Clients An IT services firm often runs agents on different frameworks for different clients, with little room to redo an integration after a major version change. Agent Framework 1.0 reduces that risk for the pieces it has stabilized, including MCP-based tool access. The same risk still applies to any integration built specifically on A2A, since Microsoft has not yet committed to its long-term compatibility. #### Migrating from the Release Candidate, AutoGen, or Semantic Kernel Teams already on the Release Candidate move to 1.0 with a package version bump, according to Microsoft. Teams coming from Semantic Kernel or AutoGen have dedicated migration guides from Microsoft, since both projects feed into Agent Framework. None of these paths require a different protocol choice: MCP tool integrations carry over, and projects relying on A2A keep that code in preview status. #### What to Check Before Committing an Integration Before building a client integration on Agent Framework 1.0, confirm which capability it depends on. MCP-based tool access, single and multi-agent orchestration, and YAML workflows sit inside Microsoft's backward-compatibility commitment. DevUI, the Agent Harness, SDK integrations, and full A2A support do not, and Microsoft gives no date for when they will. #### Tracking Stability and Cost Across Clients with Atipol For an ESN that already tracks budgets and tickets per client, Atipol's platform keeps that same separation for agent work: each collaborator runs an agent lead with their preferred tools, while leadership gets a shared view of cross-team tickets and per-project costs. See atipol.ai/use-cases/multi-team-management for how multi-team orchestration works in practice. For audit needs tied to MCP-connected tools, atipol.ai/agentic-ai-blog/ai-agent-audit-log covers what to log and for how long. Q: Is MCP support in Microsoft Agent Framework 1.0 stable for production use? A: Yes. Microsoft lists MCP among the features in version 1.0 that are battle-tested, stabilized, and covered by its backward-compatibility commitment, as stated in the April 3, 2026 announcement. Q: Is A2A (Agent2Agent) support also stable in version 1.0? A: No. Microsoft's own announcement states that full A2A 1.0 support is coming soon, without a committed date, so it does not yet carry the same backward-compatibility guarantee as MCP. Q: Do teams need to rewrite their integrations to move to Agent Framework 1.0? A: Microsoft describes the move from its Release Candidate to 1.0 as a package version bump, and provides migration guides for teams coming from Semantic Kernel or AutoGen, rather than a rewrite. Sources: - Microsoft Agent Framework, Version 1.0 announcement, 03/04/2026: https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/ - Model Context Protocol, official documentation, docs version 28/07/2026: https://modelcontextprotocol.io/ - NuGet, Microsoft.Agents.AI package page, last updated 06/11/2026: https://www.nuget.org/packages/Microsoft.Agents.AI ### If Your AI Vendor Breaks the AI Act, Who Pays? Source: https://atipol.ai/blog/ai-act-sanctions-gpai Author: Younes Azabar, founder of ETCSEC If your AI vendor's model is not compliant with the AI Act, the fine usually falls on the vendor, not on your company. The AI Act lets the European Commission fine providers of general-purpose AI models up to 3% of global annual turnover, or 15 million euros if higher, from 2 August 2026, while a company that only deploys such a model carries separate deployer duties rather than that specific fine. #### A deployer's question, not a lawyer's DSI and RSSI teams keep asking the same question: if an AI vendor's model is not compliant with the AI Act, does the fine land on the vendor or on the company that only uses it? The answer turns on one distinction: the AI Act's fining power targets providers of general-purpose AI models, not every company that deploys them. #### Who the AI Act calls a provider Article 3(3) of the AI Act defines a provider as a party that develops a general-purpose AI model, or has one developed, and places it on the market, whether established inside or outside the EU. Integrating that model into an AI system made available to others also counts as placing it on the market, with narrow exceptions. Most companies that simply call a vendor's model through an API do not meet this definition themselves. #### What triggers the Commission's fine Article 101 of the AI Act lets the Commission fine a general-purpose AI model provider up to 3% of its global annual turnover, or 15 million euros, whichever is higher. The AI Office can also request information under Article 91, evaluate the model under Article 92, or require risk mitigation under Article 93. Provider obligations became applicable on 2 August 2025, and the Commission's enforcement powers apply from 2 August 2026. #### When a deployer becomes a provider A company that only runs a vendor's model as supplied is not its provider. That changes if the company fine-tunes or otherwise modifies the model enough to create what the Commission treats as a new model. The Commission's Guidelines on the scope of obligations for providers of general-purpose AI models, section 3.2, set an indicative criterion: training compute used for the modification above about a third of the original model's training compute. Past that point, the company that modified the model takes on the provider's obligations and fine exposure for the version it created. #### Provider duties versus deployer duties, side by side The table below separates what falls on the general-purpose AI model provider from what falls on a company that only deploys the model, based on the Commission's own guidance on these roles. It is a starting checklist, not a legal opinion on any single vendor contract. | Question | Model provider | Company that only deploys it | | Can the AI Office fine it under Article 101? | Yes, up to 3% of global turnover or 15 million euros, whichever is higher | No, unless it becomes a provider itself | | Must it supply technical documentation under Articles 53 and 91? | Yes | No, that duty sits with the provider | | Does fine-tuning the model change its status? | Not applicable | Yes, above the Commission's one-third compute threshold (guidelines, 18 July 2025), it can become a provider of a new model | | Must it still meet AI Act duties for its own AI system? | Yes, as provider of that system | Yes, as deployer of that system | #### What to check before you worry about Article 101 A DSI or RSSI does not need to assess whether a vendor's model is a general-purpose AI model under the Act; the vendor carries that classification and its own paperwork. What the team can check directly is narrower, and still useful day to day. - Ask the vendor for its role: provider of the model, or reseller of another provider's model. - Ask whether the model has been fine-tuned in-house past the point where the company itself could become a provider. - Keep a record of which model version is deployed, and when, independently of the vendor's own documentation. - Treat the vendor's AI Act status as one input among others when choosing or renewing a contract, not as a substitute for the company's own deployer duties. #### Governing the deployer side while the vendor question is open Whatever a vendor's provider status turns out to be, the company stays responsible for governing its own AI agents day to day. Atipol's compliance audit use case has agents gather evidence in read-only mode, with a person reviewing each control and an exportable audit log. See the details here: https://atipol.ai/use-cases/compliance-audit. For what an agent's own audit log should record, see https://atipol.ai/agentic-ai-blog/ai-agent-audit-log. Q: Does the AI Act fine every company that uses a non-compliant AI model? A: No. The fines in Article 101 target providers of general-purpose AI models. A company that only deploys a vendor's model, without substantially modifying it, is not itself that provider. Q: What is the maximum AI Act fine for a general-purpose AI model provider? A: Up to 3% of the provider's global annual turnover, or 15 million euros, whichever amount is higher, once the Commission's enforcement powers apply from 2 August 2026. Q: Can a company that fine-tunes a vendor's model become a provider itself? A: Yes. The Commission's Guidelines on the scope of obligations for general-purpose AI model providers (18 July 2025, section 3.2) treat substantial fine-tuning, indicatively training compute above about a third of the original model's, as creating a new model whose fine-tuner becomes its provider. Sources: - European Commission, AI Act Service Desk: general-purpose AI model obligations, accessed 10 November 2026: https://ai-act-service-desk.ec.europa.eu/en/node/999 - European Commission, Regulatory framework for AI, accessed 10 November 2026: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai - European Commission, General-purpose AI models under the AI Act: Questions & Answers, accessed 10 November 2026: https://digital-strategy.ec.europa.eu/en/faqs/general-purpose-ai-models-ai-act-questions-answers - European Commission, Guidelines on the scope of obligations for providers of general-purpose AI models, published 18 July 2025: https://digital-strategy.ec.europa.eu/en/library/guidelines-scope-obligations-providers-general-purpose-ai-models-under-ai-act ### AI agent audit log: what should it record? Source: https://atipol.ai/blog/ai-agent-audit-log Author: Younes Azabar, founder of ETCSEC An AI agent audit log must answer five questions: which agent acted, on whose behalf, with which tool, on which data and with which human approval. It excludes secrets, keeps personal data to what is necessary and, for a high-risk system under the AI Act, is kept for at least six months. #### Why log an AI agent An AI agent does more than answer: it calls tools, reads files and changes systems. Without a log, nobody can reconstruct who did what after an incident. For high-risk systems, Article 12 of the AI Act also requires that the system technically allows the automatic recording of events over its entire lifetime. #### The five things to record Each log entry should make sense on its own, without extra context. The table below gives the useful minimum for an audit: the agent's identity, the person responsible, the action taken, the data affected and the approval decision. Add a precise timestamp and a unique identifier to link the entries of a single task. | Item | Example | Audit question | | Agent | Writing agent, model version | Which agent acted? | | Owner | Person or team that started the task | On whose behalf? | | Action | MCP tool call, command, write | What did it do? | | Data | File, table or folder affected | What did it act on? | | Approval | Human approval, refusal or automatic check | Who authorised it? | #### Link every action to an approval The log must show who authorised an action, not only that it happened. In a team of agents, each person has their own agent lead: it reviews the work of the agents it assigned and decides whether to integrate it, and that decision belongs in the log. For an irreversible action, such as publishing or deleting, also record the explicit human approval that came before it. #### What must never be logged An audit log must not contain passwords, access tokens or API keys, even truncated. The GDPR also requires data minimisation: keep only the personal data needed for the purpose of the log. Prefer a document identifier to its content, and mask sensitive fields before writing the entry rather than afterwards. #### How long to keep the log For a high-risk AI system, the AI Act sets a minimum: automatically generated logs are kept for at least six months, by the provider (Article 19) and by the deployer (Article 26), unless Union or national law provides otherwise. For other agents, set a retention period in your internal policy and apply it everywhere. #### Limit what the agent can do A good log does not replace limited rights. OWASP lists excessive agency among the top ten risks of applications built on large language models in 2025: too many tools, too many permissions or too much autonomy. Give each agent only the tools its mission needs, and log refused access attempts as well. #### Make the log usable in an audit The NIST AI Risk Management Framework organises the work into four functions: govern, map, measure and manage. The log notably serves measure (MEASURE 2.4, monitoring in production) and manage (MANAGE 4.1, post-deployment monitoring and incident response). To be useful in an audit, it must be exportable, protected against modification and readable by someone outside the team that deployed the agent. #### Audit log, by the numbers Two numbers summarise this framework: how many fields a log entry needs, and how long a high-risk system must keep it. - 5 Fields per log entry (Agent, owner, action, data, approval) - 6 Minimum retention (months) (AI Act, Art. 19 & 26, high-risk systems) Q: Should every agent answer be logged? A: No. Log the actions that have an effect: tool calls, writes, publications and approval decisions. The full text of conversations is only useful if your policy justifies it, while respecting data minimisation. Q: Does Article 12 of the AI Act apply to every agent? A: No. Article 12 covers high-risk AI systems. For other agents, a log remains good governance practice, but its form and retention period are a matter for your internal policy. Q: Who should be able to read the log? A: At least the person responsible for the agent and an independent control function, such as security or internal audit. Restrict write access so that the log cannot be changed after the fact. Sources: - Regulation (EU) 2024/1689 on artificial intelligence (AI Act), Articles 12, 19 and 26, 13/06/2024: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai - Regulation (EU) 2016/679 (GDPR), Article 5, 27/04/2016: https://op.europa.eu/en/publication-detail/-/publication/3e485e15-11bd-11e6-ba9a-01aa75ed71a1 - NIST, AI Risk Management Framework 1.0, January 2023: https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.100-1.pdf - OWASP, LLM06:2025 Excessive Agency, 2025: https://genai.owasp.org/llmrisk/llm062025-excessive-agency/ ### AI agent governance: the 2026 complete guide Source: https://atipol.ai/blog/ai-agent-governance Author: Younes Azabar, founder of ETCSEC Governing AI agents means giving each one a scope, allowed tools, a named owner and written acceptance criteria, then proving it with an audit log. This guide covers a six-step framework, a RACI model, a usage policy example and an FAQ to start in 30 days with an AI agent governance platform. #### What is AI agent governance? AI agent governance is the set of rules that fix, for each agent, its mission, its file scope, the tools it can call and the person who answers for its work. It differs from model governance: it is not about training, choosing or evaluating a language model, but about what an agent actually does once it is put to work, ticket after ticket, on a real project. An agentic AI agent does not just answer a question: it reads code, writes files, calls external tools and chains intermediate decisions without a check at every step. Without a written framework, two agents can edit the same file at the same time, one agent can silently exceed its scope, or nobody knows anymore who reviewed a delivery before it was merged. Governance answers three questions for every action taken: who is allowed to take it, within which exact scope, and who reviewed it before a human approved it. This is not an extra layer of paperwork: it is the condition for letting an agent work without a human reviewing every line in real time. #### Why AI agent governance becomes critical in 2026 Three trends overlap at the same time. Teams run several agents in parallel, sometimes on the same project and the same files, which multiplies the risk of conflicts and scope drift if nothing is written down in advance. Costs follow a different curve than expected: a team of agents in plan mode consumes noticeably more tokens than a single session, and costs per run, per ticket, per agent and per model need to be tracked at the same level of detail as the work actually delivered. Ignoring this tracking is like running a budget with no dashboard, until the monthly bill surprises everyone. The European AI regulation (2024/1689, known as the AI Act) requires human oversight and documentation for high-risk systems, with obligations that ramp up through 2027 and 2028 depending on the category. Meanwhile, agentic AI is spreading through teams without a written framework in many organizations: unsupervised usage, access broader than necessary, deliveries approved by their own author for lack of a second reviewer. AI agent governance closes that gap before an external audit or a regulator does it for you. Teams that wait for a notice or an incident before writing their first rules lose time they could have spent on a framework they chose rather than one forced on them. #### A six-step framework for governing your AI agents This framework is set up in order, with no step skipped: each one builds on the previous one to stay verifiable across the whole lifecycle of an agent. Skipping a step, even to move faster, weakens every step that follows. - Inventory: list every active agent, the project and organization it serves, and the agent lead who answers for its work to the team and to you. - Job description and scope: for each agent, a written mission, a scope of allowed files and an explicit list of what remains forbidden. - Rights and tools: detailed allowed-tool profiles role by role, with explicit human approval required before any sensitive or irreversible action. - Tickets with written criteria: acceptance criteria set in writing before work starts, never added after the fact once a delivery is already done. - Human review before merging: the agent lead reviews the delivery, never its own author, before the human keeps the final decision to merge it. - Cost measurement and audit log: cost tracked in tokens and in money per run, and an exportable history of every ticket for audit. #### The RACI model for AI agent governance The RACI model splits four roles across every activity in an agent's lifecycle: who does the work (Responsible), who answers for it to the organization (Accountable), who is consulted before a decision (Consulted) and who is only informed of the outcome (Informed). Applied to AI agents, it avoids the most common situation in teams that are just starting out: nobody knows who decides when an agent strays outside its declared scope. Without this written split, two agents or two humans can each believe the other holds final responsibility, which delays any decision at the worst possible moment. This table gets reread at every change in the organization: a new project, a new agent lead or a new offer must never leave an activity without a clearly named Accountable, at the risk of a production delivery nobody answers for in front of the team or an external audit. | Activity | Responsible | Accountable | Consulted | Informed | | Ticket and criteria creation | Agent lead | Requesting human | Project team | Related agents | | Executing the assigned work | Agent worker | Agent lead | Peer agents | Requesting human | | Review before merging | Agent lead | Requesting human | Agent worker | Project team | | Final approval and merge | Requesting human | Requesting human | Agent lead | Project team | | Cost and log tracking | Agent lead | Organization owner | Agent worker | Finance team | #### An AI agent usage policy example A usage policy fits on one page and gets reread in a technical committee once a quarter. Here is an example to adapt, built directly on the six steps of the framework above. It does not replace an individual job description, it sums up its spirit for the whole team: - Every agent has a job description published and reviewed by the agent lead before its very first run on a real project of the organization. - No agent touches a file outside its declared scope, even for a fix judged minor or urgent by its operator. - Sensitive tools, such as writing to production or sending an external message, require explicit, justified human approval before every call. - A ticket without written, dated acceptance criteria never goes into execution, whatever urgency the requester claims. - No agent, human or artificial, approves its own delivery: review always goes to the agent lead, then to the responsible human. - Cost per ticket is reviewed every week by the agent lead and the organization owner, not only at the end-of-month invoice. #### Model governance versus operational agent governance Model governance covers the choice, evaluation, training and bias of a language model: it answers the question 'is this model reliable and safe in general?'. Operational agent governance covers the actual use of that model once it is put to work: it answers a different question, 'does this specific agent do what it was asked, within its scope, with evidence you can show afterwards?'. Confusing the two levels often leads to investing only in model evaluation, leaving the agents' day-to-day work with no written rule at all. Both levels are necessary and never replace one another. An evaluated, tested model judged safe can still produce a poorly framed agent, with too broad a scope, badly set rights or no human review before its work is merged. Conversely, a solid operational framework, with job descriptions and an audit log, does not fix a model that is structurally biased or poorly evaluated upstream. AI agent governance assumes the other level, it does not replace it. A serious company documents both levels separately, with different owners and different evidence for each. #### How Atipol applies this framework In Atipol, every agent has a job description: a mission, a scope of allowed and forbidden files, allowed tools and MCP connection profiles specific to its role. An agent lead answers for its work to the organization; one person drives one agent lead session at a time, and the same project can have several agent leads depending on its size. Every ticket carries its written acceptance criteria from its creation, before work begins. Plans range from Free to Business, with a custom Enterprise offer for organizations with specific needs. The delivery is reviewed by the agent lead before any merge: a worker never approves its own work, and the human keeps the final decision, with the option to require extra approvals in its most sensitive workflows. Costs are tracked in tokens and in money per run, per ticket, per agent and per model, and an exportable audit log keeps the trail of every step, from the request to the merge. Coordination data is encrypted per organization under a master key in a hardware vault, and the code stays on your machines: agents on Mac, Windows, Linux or a Docker runner, with Claude Code, Codex, Cursor or any other MCP client. This choice avoids locking a team into a single editor or model provider. #### Common mistakes in AI agent governance The same mistakes come back from one project to the next, often in the first few weeks, before a team has had time to adjust its habits: - Writing acceptance criteria after the fact, once the delivery is already done, which turns review into negotiation rather than verification. - Letting an agent approve its own delivery for lack of a second reviewer available when the ticket wraps up. - Giving too broad a file scope to move faster, then discovering an unplanned change several days later. - Tracking cost by month rather than by ticket, and discovering a budget overrun only once the invoice has already arrived. - Confusing model governance and operational agent governance, and only seriously addressing the first of the two. - Keeping no exportable log, hence no evidence to present during an internal review or an external audit. #### Where to start: a 30-day plan Rolling out this framework does not need to be complete from day one, nor does it need to block deliveries already underway. Here is a realistic pace for a team getting started: - Days 1 to 5: full inventory of active agents and naming of a responsible agent lead per ongoing project. - Days 6 to 10: writing job descriptions and allowed file scopes for every existing agent. - Days 11 to 20: systematically rolling out tickets with written acceptance criteria before any new work is assigned. - Days 21 to 25: human review before merging applied without exception, even on urgent deliveries. - Days 26 to 30: first cost-per-ticket review and first full export of the audit log for review. Q: What is AI agent governance? A: It is the set of rules that fix the scope, rights, budget and review of every agent, with an audit log that lets you prove afterwards what actually happened on a given ticket. It applies to an agent's real work, not just to the quality of the model it uses. Q: Why use an AI agent governance platform rather than manual rules? A: Because a platform applies the framework to every ticket without depending on a team's memory: scope, criteria and review are checked at every delivery, not just documented in a file nobody opens again. The result: fewer silent incidents and a review that focuses on the work, not on paperwork. Q: What is the RACI model applied to AI agents? A: It assigns, for every activity such as ticket creation, execution, review or approval, who does the work, who answers for it, who is consulted and who is only informed of the final outcome. Q: Does agentic AI change governance compared to a simple assistant? A: Yes: an agentic AI agent actually acts, it writes, it calls tools, it decides intermediate steps; so you need to govern its real actions, not just the quality of its answers. Q: What does keeping a human in the loop mean? A: That the human keeps the final decision on every approval and can require extra approvals in its workflows, even when most of the day-to-day work is already automated by agents. This is what distinguishes a governance framework from plain automation with no oversight. Q: What is an audit log on AI agents for? A: It links every action to a specific agent, a ticket and a responsible person, and exports for a regular internal review or an external check, for example a regulatory one. Q: How do you track cost per delivery rather than per month? A: By measuring cost in tokens and in money per ticket, then relating it to deliveries actually approved, not only to the overall invoice seen at month end. Q: AI agent governance and AI Act compliance, is that the same thing? A: No: the AI Act sets legal obligations based on a system's risk level, while operational agent governance is the internal practice that helps meet them, without ever fully replacing them. The two frameworks complement each other: one sets the legal floor, the other organizes day-to-day work around that floor. Sources: - EU Regulation 2024/1689 on AI (AI Act), EUR-Lex, July 12, 2024: https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32024R1689 - NIST, AI Risk Management Framework 1.0, January 26, 2023: https://www.nist.gov/itl/ai-risk-management-framework - ANSSI (cyber.gouv.fr), security recommendations for generative AI, 2024: https://cyber.gouv.fr/ - MCP specification, Security Best Practices: https://modelcontextprotocol.io/specification/latest/basic/security_best_practices ### How much do AI agents really cost? 2026 figures and a method Source: https://atipol.ai/blog/ai-agent-costs Author: Younes Azabar, founder of ETCSEC For a coding agent, Anthropic reports about $13 per developer per active day for Claude Code, or $150 to $250 per month. Several agents in parallel multiply that figure, and 85% of companies misestimate their AI costs by more than 10%. The right measure is not the monthly bill but the cost per accepted delivery. #### The cost items of an AI agent team The most visible line in an AI agent team's bill is the model's subscription or API: input, output and cache tokens, at rates each provider publishes and that vary sharply from one model to another. But that single line tells only part of the story. The human time spent framing and reviewing work, the redone work after a rejected delivery, and the tooling that runs around the agents' work weigh just as much on the real cost, often more over time. Ignoring these items is like managing a budget by looking at a single line of the bill, and discovering the rest at the most uncomfortable moment: the end-of-month statement. Running several agents in parallel amplifies several of these items at once, not just the token one. According to the Claude Code documentation, an agent team in plan mode uses about seven times more tokens than a single session, because each agent reloads its own context and coordination between agents adds further exchanges. Human review time follows a similar curve: more agents running in parallel means more deliveries to check in the same window of time, not automatically faster unless someone adds review capacity to match. Parallelism saves time on a project, rarely money on the full bill, unless you treat it as a conscious trade-off rather than a reflex applied to every ticket. The cost of tooling around the work grows with the number of agents too, even if no one thinks about it when signing up for a model subscription. Ticket orchestration, storing the exchanges between an agent and a ticket, and the continuous integration that checks every delivery before merging it all consume resources independent of tokens, but necessary for the agents' work to stay traceable. A team that only budgets for tokens often discovers this item at the same time its hosting or continuous integration bill climbs with the number of tickets processed each month. - Model subscription or API: input, output and cache tokens, at rates that vary by provider, by model and by context size. - Human framing time: writing the mission and acceptance criteria for a ticket before launching an agent on it. - Human review time: checking a delivery before merging it, an item that never disappears, whatever model is used. - Redone work after a failed delivery: a rejected ticket gets redone, so it gets paid for twice, in tokens as in human time. - Tooling around the work: ticket orchestration, storing exchanges and continuous integration, which run even when no agent is working. #### Why cost per token is misleading Comparing two models on token price alone almost always leads to the wrong conclusion. A model that is twice as cheap per token can produce a rejected delivery half the time, while a more expensive model delivers on the first try because it follows criteria written in advance more closely. Token price measures consumption, not a result. The question that matters is not how much this run costs, but how much it costs, in total, to get a delivery you actually accept to merge. The right metric is cost per accepted delivery: the sum of the costs of every run a ticket required, divided by the number of tickets actually merged. A ticket that needed three attempts before being accepted should carry the cumulative cost of those three attempts, not just the cost of the last one. It is this division, the cost of runs over merged tickets, that reveals whether a cheaper-per-token model still is once redone work is counted. Take a fictitious numeric example, built to illustrate the calculation and not to describe a real customer. A ticket assigned to a budget model costs $0.40 in tokens per run; for lack of precise enough criteria, it needs three runs before an accepted delivery, so $1.20 in total for one merged ticket. The same ticket, assigned to a more expensive model but with criteria written in advance and a review before merging, costs $0.90 in tokens and passes on the first try, so $0.90 for one merged ticket. In this example, the model that is cheaper per token ends up costing more once redone work is counted. The exact figure varies by team and by ticket; what does not vary is the need to divide the cumulative cost by deliveries actually accepted rather than by the number of runs launched. The same calculation scales to a whole team: sum, over a given period, the cost of every run of every ticket, then divide that total by the number of tickets actually merged over the same period. Two teams spending exactly the same amount on tokens in a month can show a very different cost per accepted delivery if one merges twice as many tickets as the other on the same budget. It is this ratio, not the total tokens consumed, that lets you honestly compare two models, two teams or two months. Tracking only total spend, without this denominator, is like comparing bills without knowing what they actually paid for. The same division applies whatever model provider you use: the list price published on a pricing page never says, by itself, how many runs a given ticket will actually need before being accepted. Two teams using the same model, at the same rate, can end up with a very different cost per accepted delivery depending on how clear their criteria are and how rigorous their review is before merging. Ignoring this measure has a real cost: according to CIO.com, 85% of companies misestimate their generative AI costs by more than 10%, often because they track total spend without relating it to the deliveries obtained. At Uber, Claude Code usage burned through the year's AI budget in four months before a per-engineer cap was put in place, an example of what happens when spend is tracked monthly rather than per ticket. #### The levers that change the bill Five levers act directly on the cost per accepted delivery, regardless of which model provider you choose. None is enough on its own: it is their combination that brings the bill down, because each one tackles a different cost item from those listed above. These levers are set before launching an agent, not after the fact: a criterion added once the delivery is done changes nothing about the cost already spent. Prompt caching, for instance, assumes the repeated context stays identical from one call to the next, which favors stable role sheets rather than ones rewritten for every ticket. Choosing the model per role, in turn, assumes you know the real difficulty of each task before deciding, not after noticing redone work. Each of these levers acts on a specific item from those listed above. Choosing the model per role and prompt caching directly reduce the subscription or API line. Criteria written in advance reduce the human framing time, by avoiding back-and-forth clarification along the way. Review before merging and resumed rather than restarted sessions reduce the share of the budget that goes into redone work, the item easiest to lose sight of until a delivery has actually been rejected. Tracking these five levers ticket by ticket, rather than applying them once at the start of a project, is what lets you see which one weighs most in a given project. These five levers apply just as well to a small team as to several agents running in parallel across several projects: only the number of tickets they are checked against each month changes. A team just starting out can review them manually, ticket by ticket; a larger team gains from tracking them on a dashboard that ties each lever to a measured cost per accepted delivery, rather than one estimated after the fact. | Lever | Why it reduces the cost per delivery | | Model choice per role | Reserve the most capable model for tasks at risk of redone work, and a budget model for simple, well-framed tasks. | | Criteria written before launch | Less back-and-forth clarification during the run, so fewer tokens spent before the first delivery even happens. | | Review before merging | An error found before merging costs a review; found after, it costs a fix and a whole new cycle. | | Resumed rather than restarted sessions | Resuming a session keeps the context already paid for in tokens; restarting from scratch pays for it a second time. | | Prompt caching | A context repeated from one run to the next, like a stable role sheet, is billed at the reduced cache rate rather than the full rate on every call. | #### How Atipol measures it In Atipol, cost is tracked in tokens and in euros by run, by ticket, by agent and by model: you see exactly which item consumed what, from a single run down to the sub-ticket, without waiting for the end-of-month bill to find out. This tracking applies equally to a per-seat subscription, predictable for daily use, and to an API key billed by usage; many teams combine both depending on the role. A monthly budget per provider key is tracked with an alert at a set threshold, so you decide what comes next already knowing the spend engaged rather than discovering it afterward. This granularity answers different questions. Cost per run tells you how much a single call to the model cost. Cost per ticket adds up every run of a ticket, accepted or rejected, and relates to the number of deliveries merged to get the cost per accepted delivery described above. Cost per agent tells you which role consumes the most in a given project. Cost per model tells you whether the model chosen for a role is still the right choice once redone work is counted, or whether it is worth switching for that specific role. The same tracking also reads by project: an organization running several projects in parallel sees which one consumes the most, and can adjust the budget project by project rather than only at the whole organization's level. Plans range from Free to Enterprise, by quote. Pro, at €19 including tax per user per month, or €152 per year, and Business, at €39, add the features built for a team running several agents across several projects. Enterprise is discussed by quote for organizations with specific needs, for example a ticket volume or a number of projects beyond the standard plans. Atipol does not save tokens on your behalf: it measures spend, alerts once it nears a set threshold, and requires an explicit confirmation before switching to a more expensive model, an option you can also forbid role by role. The decision stays human and informed, not automatic. This tracking by run, by ticket, by agent and by model is what lets you calculate, project after project, the one figure that actually matters: the cost per accepted delivery described above. Q: Does Atipol save tokens? A: That is not what it promises: it measures spend in tokens and in euros by run, by ticket, by agent and by model, and requires an explicit confirmation before switching to a more expensive model, an option you can also forbid role by role. You decide knowing the cost, not after the bill. Q: How do I track spend by model provider? A: With a monthly budget tracked per provider key and an alert at a set threshold, so you decide what comes next already knowing the spend engaged rather than discovering it on the end-of-month bill. Q: Do I have to choose between subscription and API? A: No: a per-seat subscription is predictable for daily use, the API bills by usage for occasional spikes, and many teams combine both depending on the role. Q: What is cost per accepted delivery? A: It is the cumulative cost of every run a ticket required, divided by the number of tickets actually merged. It is the metric that reveals whether a cheaper-per-token model still is once redone work is counted. Q: Does prompt caching really reduce the bill? A: Yes, for context repeated from one call to the next, like a stable role sheet: it is then billed at the reduced cache rate rather than the full rate on every call, as confirmed by model providers’ pricing pages. Q: Which Atipol plans track these costs? A: Free, Pro at €19 including tax per user per month (€152 per year), Business at €39, and Enterprise by quote for organizations with specific needs. Sources: - Claude Code, Manage costs: https://code.claude.com/docs/en/costs - CIO.com, AI cost overruns, September 10, 2025: https://www.cio.com/article/4064319/ai-cost-overruns-are-adding-up-with-major-implications-for-cios.html - Outlook Business, Uber, 2026: https://www.outlookbusiness.com/corporate/uber-caps-ai-tool-usage-after-exhausting-yearly-budget-in-just-4-months - Anthropic (Claude), pricing: https://platform.claude.com/docs/en/about-claude/pricing - OpenAI, API pricing: https://developers.openai.com/api/docs/pricing ### MCP security: 12 controls before connecting a server to your agents Source: https://atipol.ai/blog/mcp-security Author: Younes Azabar, founder of ETCSEC MCP is neither safe nor dangerous in itself: it all depends on the servers you connect and what you allow them to do. Of nearly 8,000 MCP servers exposed on the internet, 40% have no authentication at all. Allow known servers, tool by tool, with human approval on sensitive actions and a log of the calls. #### What is an MCP server, and why does it widen the attack surface The Model Context Protocol (MCP) is an open protocol that lets an AI agent call external tools: read a file, query a database, send a message, trigger an action in another service. Every MCP server connected to an agent adds one more access point between that agent and the rest of the information system, with its own tools, its own permissions and, often, its own authentication token. Before MCP, a coding agent read and wrote files inside a repository; with an MCP server connected to a storage space, a messaging tool or a tracker, the same agent can act well beyond that original scope, with the same consequences as a poorly scoped service account. Three elements concretely change an agent's attack surface once an MCP server is connected. Tools, first: every function the server exposes becomes an action the agent can trigger, sometimes without the human operator knowing precisely which one was chosen at a given moment. Access, next: a server connected to a database or a file store often gives the agent a scope wider than what the current ticket actually needs, especially when the server offers no finer granularity than full access. Tokens, last: the server carries or relays authentication toward the system it exposes, and a poorly isolated or poorly verified token becomes a single point of failure between an agent and permissions that should never belong to it directly. The MCP specification recommends that a human be able to deny any tool call before it runs, precisely because these three elements add up quickly. MCP is in itself neither safer nor more dangerous than any other integration: the risk comes from the servers you connect and the permissions you leave them, not from the protocol itself. A server limited to reading a single folder, with a dedicated token and a restricted tool list, exposes almost nothing more than the agent already had. The same server configured with full access to a production database, a token shared with other uses and no list of what it can do, turns a simple tool addition into a risk that reaches far beyond the agent that uses it. Take a concrete example: a coding agent connected to a file system MCP server, configured for convenience on the user's personal folder rather than on the project repository alone. The current ticket only asks to read a configuration file, but the agent can, technically, list and read any other file in the same folder, including a private key or a password list left there by mistake. Nothing in the protocol prevents this wide scope; it is the server's configuration, not MCP itself, that decides whether the actual scope granted matches the ticket's real need. #### The documented risks Four families of risk keep coming up in public research on MCP and in OWASP's work on large language model applications. Each one has already been observed outside a lab, not only demonstrated in theory, and each stays directly linked to one of the three elements described above: tools, access or tokens. The first risk is tool poisoning: a malicious or compromised MCP server slips hidden instructions into the description of a tool the agent reads, instructions the human user never sees. In April 2025, the research lab Invariant Labs documented a real attack against an MCP server connected to WhatsApp: a side tool, presented as a simple daily fact lookup, carried a hidden instruction that pushed the agent to silently change the recipient and content of an outgoing message, exfiltrating the conversation history to the attacker through WhatsApp itself. The report notes that several consumer MCP clients executed that instruction without any signal warning the user. The lesson is not about one particular vendor: it is that an agent reads a tool's description as just another instruction, unless its operator explicitly prevents that. This kind of attack works precisely because a side MCP server, added for a function judged harmless, can coexist with a more sensitive one with no barrier separating what one can read from what the other can write. The second risk is token passthrough and the confused deputy problem: an MCP server relays a token to a third-party service without verifying it was issued for the server itself, or acts with permissions that are not its own because an attacker manipulated it into borrowing them. The MCP specification describes this scenario precisely for servers acting as an OAuth proxy toward a third-party API with a single, static client identifier: without per-client verified consent, an attacker can make the server act on their behalf against the remote service. The specification explicitly forbids token passthrough for this reason and requires a server to validate every token directly against its issuer rather than relaying it unchecked. The same principle applies outside the OAuth proxy case: any MCP server that accepts a token without verifying it was really meant for it opens the door to a compromised third-party service, able to borrow the agent's identity to act in its name well beyond what its operator authorized. The third risk is the ghost server: a developer installs an MCP server on their machine or inside a project, for example to connect to a production database or an internal storage space, without the security team or the organization ever knowing about it or validating its permissions. A public study counting nearly 8,000 MCP servers exposed on the internet found that 40% of them required no authentication at all, which means a server installed without review can stay reachable well beyond the machine or the project it was added for, sometimes for a long time. The same work notes that the lack of authentication affects test servers forgotten online just as much as servers connected, without anyone quite deciding so, to real data; reviewing already-connected servers periodically therefore matters just as much as reviewing the very first addition. The fourth risk is excessive exposure: a tool designed for one precise task, for example reading a configuration file, actually gives access to an entire folder, a full database or a production instance, because the server offers no finer granularity than a blanket access. OWASP places this risk under excessive agency in its recommendations for large language model applications: an agent that can do more than its ticket requires may, one day, actually do it, either through a manipulated instruction or through a simple reasoning mistake about which tool to use. A poorly scoped file-reading tool can thus grant access to an entire customer database rather than the single record the ticket expected, without any line of the agent's code ever explicitly asking for such a scope. #### Controls to put in place before connecting a server Six controls cover most of the risks documented above. None of them depends on any particular MCP server vendor, and each addresses one precise risk rather than a general recommendation for caution. Secrets, meaning the keys and tokens an MCP server uses, must stay out of versioned source code and out of the prompt sent to the model: a secret visible in a configuration file or in an agent's context can be copied, re-read or passed on to a third party without any deliberate malicious action being needed. Human approval on sensitive actions, such as a production write or sending a message to the outside world, adds a stopping point before an irreversible action goes through, exactly where a manipulated instruction would do the most damage. Logging every call, finally, prevents no incident on its own, but it turns an unanswerable question, such as what this agent did and when, into a few minutes of searching an exportable history. These six controls belong before a server is connected, not after a first incident: a list of allowed tools decided after the fact does not undo the calls already made, and a log added after a leak no longer helps work out what was actually read or written. The simplest one to apply first remains the list of tools allowed per agent: an agent that can only call the tools its ticket needs cannot, through a reasoning mistake or a manipulated instruction, use another one its operator never authorized. Separating connections by project deserves particular attention in organizations running several projects with MCP agents: a connection shared between two projects exposes one to the permissions and risks of the other, even when both belong to the same organization. Reviewing servers before adding them remains the only control that acts before the server ever runs: it checks the publisher, the version and the scope of the declared tools, exactly what would have caught the side tool behind the WhatsApp attack before it was ever connected. | Risk | Control | Who owns it | | Privilege abuse by an agent | List of tools allowed per agent | Agent lead, in the job sheet | | Irreversible action triggered without oversight | Human approval on sensitive calls | Human operator | | Theft of secrets, a token or an exposed key | Secrets out of the code and out of the prompt | Security team | | No evidence after an incident | Log of every call | Agent lead | | Permission leakage between two projects | Separation of connections per project | Organization administrator | | Ghost server added without review | Server review before adding | Security team | #### How Atipol does it In Atipol, each agent has its own MCP profile: the list of tools it is allowed to call, assigned role by role rather than to the whole project. An agent in charge of reviewing code does not have access to the same tools as an agent in charge of deploying, even if both work on the same project at the same time. MCP connections themselves are managed at the workspace level, which keeps a connection added for one project from becoming available elsewhere without an explicit decision, and gives the team a single view of what is actually connected. MCP rules are set at the organization level: a workspace can apply them more strictly, never bypass them agent by agent, which keeps a local exception opened for one rushed project from quietly becoming the rule for every other one. When an MCP call requires approval, the project's lead agent grants or denies it, with the ticket's context in view rather than an isolated call with no explanation; a request left unanswered expires after 30 minutes, rather than staying open indefinitely while waiting for a human busy elsewhere. Keys used by MCP connections are kept in a vault encrypted under the organization's key, never shown in clear text in a configuration file or in the context sent to a model, which strips the prompt itself of any value if it ever leaks. Atipol does not, on its own, detect MCP servers installed outside the platform, and does not replace a security review of the servers themselves: it governs the connections and calls that pass through its own framework, not what happens entirely outside it. Q: Is a local MCP server safer? A: It reduces network exposure, not the risk of misuse: a local server with too many permissions or a shared token is still dangerous. A server's location never replaces a list of allowed tools and a review before adding it. Q: How do you audit MCP calls? A: With a log that links every call to an agent, a ticket and a result. In Atipol, that log comes with the human approval the lead agent granted or denied for the calls that required it. Q: Do you need an MCP gateway? A: A gateway filters calls at the network level; it does not say who asked for the call, in which ticket, or against which criteria. Atipol governs that second layer, on top of a gateway if your organization already uses one. Q: What is token passthrough? A: It is when an MCP server accepts a token that was not verified as issued for it and relays it to another service. The MCP specification explicitly forbids this, since relaying exposes the account the token was issued to. Q: Who approves a sensitive MCP call in Atipol? A: The project's lead agent approves or denies each MCP call that requires it. A request left unanswered expires after 30 minutes, rather than staying pending indefinitely. Q: How do you avoid ghost MCP servers? A: By reserving the addition of a new server for a prior review and by separating connections per project, so a server installed for one use never becomes reachable elsewhere without an explicit decision. Sources: - MCP specification, Security Best Practices: https://modelcontextprotocol.io/specification/latest/basic/security_best_practices - "Exposed by Design", arXiv 2608.00150: https://arxiv.org/pdf/2608.00150 - OWASP GenAI, Excessive Agency (LLM06:2025): https://genai.owasp.org/llmrisk/llm062025-excessive-agency/ - Invariant Labs, WhatsApp MCP Exploited, 04/2025: https://invariantlabs.ai/blog/whatsapp-mcp-exploited ### Running several Claude Code agents in parallel: what works, what breaks Source: https://atipol.ai/blog/parallel-claude-code-agents Author: Younes Azabar, founder of ETCSEC To have several Claude Code agents work at the same time, give each one its own git worktree and branch. Beyond three or four agents, the real problems are file conflicts, review and cost: you need one ticket per agent, a file scope and a review before merge. #### Why parallelize, and what breaks starting with the second agent A human development team almost never works with a single engineer at a time on an active project: several people make progress in parallel on different parts of the same repository, with a system of branches, review and integration that has been refined for this purpose for years. The same logic applies to Claude Code agents: in principle, nothing prevents several agents from working on the same project at the same time, as long as each one stays within its own scope, the same way you would expect a human engineer not to touch a colleague's module without prior coordination. Running a single Claude Code agent at a time has a simple limit: the total time stays the sum of each task's time, even when several tasks have strictly nothing in common. Translating an article into six languages, fixing a server-side bug while fleshing out a documentation page, or advancing three independent tickets from the same work item are all cases where nothing requires waiting for one agent to finish before launching the next. Parallelizing several Claude Code agents, whether through sub-agents in a single session, coordinated agent teams, or independent sessions in separate worktrees, promises to bring that total time down to the duration of the longest task rather than the sum of all the tasks. Launching several agents in parallel is almost never the problem: any terminal can open several Claude Code sessions within seconds. The problems start as soon as two agents touch, even briefly, some shared state, whether that is a file, a branch, a local server port, or a review budget already occupied elsewhere. Four symptoms tend to recur, roughly in this order as the number of agents increases. The first symptom is file conflicts: two agents modifying the same file at the same time, in the same working directory, almost always end up overwriting part of each other's work, especially when neither rereads the latest state before committing. The risk grows further when the two agents share the same Git working directory, meaning each one sees, at the same moment, the other's uncommitted changes, well before either has been able to validate them. The second symptom is lost context: an agent that picks a task back up after another agent has modified a neighboring file sometimes works on a version of the code that no longer exists, because its own conversation context was never informed of the change. This mismatch does not always produce an immediately visible error; it often produces code that compiles, that looks correct locally, but that contradicts a decision made in the meantime by a neighboring agent on the same file or on a file that depends on it. The third symptom is review saturation: every additional agent produces an additional diff to review, and review does not parallelize as easily as writing, because it requires human attention or automated review whose capacity stays roughly fixed. According to a CodeRabbit study reported by The Register in December 2025, AI co-written pull requests contain 1.7 times more issues than pull requests written without assistance: multiplying agents without multiplying review capacity amounts to accumulating a debt that only becomes visible at integration time. The fourth symptom is cost, which climbs faster than the number of agents rather than at the same pace: each agent rebuilds part of its own context in every session, each conflict resolved after the fact consumes tokens again to reread and fix, and poorly framed coordination between agents adds back-and-forth that would not exist with a single agent. Claude Code's documentation on managing costs recommends, for this precise reason, framing the scope of each session before launching it rather than letting it grow over the course of the conversation. These four symptoms are not arguments against parallelization itself: they simply indicate that beyond one agent, the coordination work does not disappear, it shifts from writing code to defining scope, criteria and review. The next section details, step by step, how to set this framework before launching the second agent rather than after noticing the first conflict. #### Step-by-step method to stay in control Five practices cover most of the symptoms described above. None depends on a particular tool: they apply just as well to sub-agents within a single session as to independent sessions launched in separate worktrees. They come in this order, because each one reduces a risk that the next one can no longer fully fix once it has happened. The first practice is a Git worktree and a branch per agent. The git worktree add command creates a separate working directory, with its own file state, while sharing the same Git history as the main repository: two agents set up in two different worktrees can no longer, by construction, see or overwrite each other's uncommitted files, even if they work on the same repository at the same time. Claude Code's documentation on common workflows describes exactly this pattern for running several sessions in parallel without them stepping on each other, with each session staying on its own branch until an explicit merge brings the work back together. An agent that finishes its task leaves behind a branch ready for review, which integration can accept or reject without ever having touched the working directory of the agents still in progress. The second practice is a file scope defined per task, before the agent starts writing. A ticket that specifies exactly which files or folders an agent is allowed to modify removes a good part of the conflict risk before it even happens, since two agents whose scopes do not overlap cannot, by definition, write to the same file. This scope should stay narrower than what the agent's general role would normally allow, because it is the ticket at hand, not the agent's role, that determines what a specific task actually needs. A scope that is too broad, even with good intentions, amounts to giving agents back the same exposure as a single agent with no breakdown at all, only spread across several sessions instead of concentrated in one. The third practice is writing the acceptance criteria before launching the agent, not after reading its delivery. A criterion written in advance, such as "the build command passes" or "the five translations cover the same sections," gives the agent a verifiable target and gives its reviewer an objective test rather than a general impression of how good the result is. Without a prior criterion, review drifts toward a case-by-case judgment call, which quickly becomes inconsistent from one agent to another and from one task to another. This same criterion also serves as a stopping point: an agent that cannot satisfy it signals a blocker before review, rather than delivering an approximate result hoping it goes unnoticed. The fourth practice is review before any integration, never after. A diff reviewed before merging can still be corrected without affecting other agents' work; a diff merged first and reviewed afterward forces you to undo an already shared history, with the risk of removing, in the process, valid work done in the meantime by a neighboring agent on a file that depends on it. Review must cover the actual diff, not just the summary the agent provides of its own work, precisely because an optimistic summary does not always reveal an acceptance criterion that was left unmet. This discipline costs a bit of time on every delivery, but it always costs less than untangling, after a merge, which of two agents produced which part of the same file. The fifth practice is limiting the number of simultaneous sessions to what review can actually absorb. Claude Code's documentation on sub-agents and agent teams recommends starting with three to five teammates before considering going further, noting that two agents on the same file almost always produce an overwrite rather than a clean merge. This number is not a technical limit of the protocol; it is a practical limit on what a reviewer, human or automated, can seriously check before integrating. Raising this number remains possible later, once file scope, acceptance criteria and review before merge are already working smoothly on a small number of agents. #### Table of pitfalls and fixes The table below lists the most common pitfalls observed beyond two agents, with their concrete symptom and the fix that avoids it; each fix maps directly to one of the five practices from the previous section. | Pitfall | Symptom | Fix | | Two agents on the same file | Part of the work gets overwritten before commit or at merge | A worktree and a branch per agent | | Unclear task scope | Two agents modify overlapping files without knowing it | A file scope written into the ticket before launch | | Missing acceptance criteria | The delivery looks finished but does not meet the actual request | Acceptance criteria written before the agent is launched | | Merge before review | A flaw found afterward forces you to undo shared history | A review of the actual diff before any integration | | Too many sessions at once | Review gets swamped and code debt builds up unnoticed | A number of simultaneous sessions limited to what review can absorb | | Context not shared between agents | An agent works on a version of the code already changed by another | One ticket per agent with its own scope, reviewed before merge | #### How Atipol handles it In Atipol, each agent works in its own Git worktree, on its own branch: two agents never modify the same files at the same time, by construction rather than by individual discipline. Each ticket reserves a file scope before the agent starts writing, and two tickets in progress cannot reserve the same scope: the risk of overwriting between two agents is removed before the first commit rather than at merge time. This reservation is checked at the very moment the ticket is handed to an agent, not after the fact during an end-of-week review, which prevents an overlap from being discovered only after both agents have already written to the same lines. Every ticket requires acceptance criteria written before the agent is launched, which prevents a task from finishing without anyone knowing exactly what needed to be true to consider it done. The project's agent lead reviews every delivery before integrating it, and this integration reruns the project's checks rather than relying solely on the review that preceded it. This review covers the actual diff produced by the agent, and the integration that follows does not simply trust the reviewer's opinion: it reruns the project's own checks itself, so that an oversight in review does not become a silent flaw in the main branch. The number of simultaneous sessions is set at the project level, so that review load and token cost stay under the team's control rather than growing with however many agents one could launch. This setting stays in the hands of the team running the project, not a parameter fixed once and for all by the platform itself. Atipol is not limited to Claude Code: the same framework of tickets, file scope and review before integration applies to other development agents. Q: Do you need a worktree for every Claude Code agent? A: As soon as two agents touch the same repository at the same time, yes: a worktree and a branch per agent remove the risk of file conflicts at the root instead of handling it after the fact. Q: How many agents can you run in parallel? A: As many as there are genuinely independent tasks. The real limit is not the number of sessions you can open, but the review capacity and budget available to check them. Q: What if two agents need to touch the same file? A: Sequence them instead of parallelizing on that specific file, or split the task so each agent gets a distinct file scope before starting. Q: Does a sub-agent replace a separate worktree? A: No: a sub-agent stays within the same session and context, for a short side task. A separate worktree is for long, independent work, on its own branch. Q: How do you keep review from becoming the bottleneck? A: By limiting the number of simultaneous sessions to what a reviewer can seriously check, and by writing acceptance criteria before launch rather than after delivery. Q: How does Atipol prevent two agents from reserving the same scope? A: Each ticket reserves a file scope before the agent starts writing, and two tickets in progress cannot reserve the same scope: the conflict is ruled out before the first commit. Sources: - Claude Code, Common workflows (git worktrees): https://code.claude.com/docs/en/common-workflows - Claude Code, Subagents: https://code.claude.com/docs/en/sub-agents - Git, git-worktree: https://git-scm.com/docs/git-worktree - Claude Code, Manage costs: https://code.claude.com/docs/en/costs - The Register, CodeRabbit, December 17, 2025: https://www.theregister.com/2025/12/17/ai_code_bugs/ ### Agentic AI, GDPR and the AI Act: what applies in 2026 and 2027 Source: https://atipol.ai/blog/agentic-ai-gdpr-ai-act Author: Younes Azabar, founder of ETCSEC An AI agent is neither compliant nor non-compliant in itself: it is how it is used that counts. The GDPR and the AI Act apply as soon as an agent processes personal data or acts in a use classified as high-risk. The AI Act's "high-risk" obligations apply from December 2, 2027 for Annex III and from August 2, 2028 for Annex I. #### Why an agent that acts changes the question A conversational assistant answers one question and waits for the next: by default it has no persistent memory between two exchanges, no access to tools able to act on an outside system, and no ability to decide a next step on its own. An agentic AI agent changes this on three points at once. It can be given access to real tools: reading and writing files, calling an API, sending a message, updating a database. It can keep context across several steps, sometimes over several days, which means personal data read at one step can influence a decision made much later. Finally, it can chain several actions without a person validating each one, which shifts part of the responsibility from the moment of the decision to the configuration that made it possible upstream. None of these three traits, tool access, context memory and chained autonomy, raises a new legal question by itself: the GDPR applies the same way to automated processing as to manual processing, and the AI Act does not distinguish an agent from a model based on the marketing vocabulary used to describe it. What changes is the surface these traits expose. An agent with access to a messaging tool and a customer database can, in a single task, read personal data, cross-reference it, then act on it: the GDPR question no longer concerns one isolated read but a chain of operations. On the AI Act side, an agent that makes a decision affecting a person, for example screening job applications or scoring risk, can fall into the high-risk classification regardless of the underlying technology. This is why the two texts now have to be read together rather than one after the other: an organization deploying an agent can no longer treat the GDPR question and the AI Act question as two separate files, since the access scope that satisfies GDPR minimization is also what reduces exposure under the AI Act, and the human oversight the AI Act requires documents, in the same move, part of what a GDPR impact assessment seeks to verify. The sections below detail each text separately, before linking them in a single check-list. #### The GDPR applied to AI agents Before giving an agent access to personal data, the first question remains the one Article 6 of the GDPR asks for any processing: what legal basis does it rest on? Contract performance, legitimate interest or consent cannot be assumed just because an agent automates a task previously done by hand; the legal basis valid for a manual process still has to be checked for its automated version, because the volume, speed and cross-referencing of data an agent enables can shift the balance between the interest pursued and the rights of the data subject. Documenting this legal basis before connecting an agent to a source of personal data avoids discovering, after the fact, that none of the bases listed in Article 6 actually covers the use made of it. The minimization principle, set out in Article 5 of the GDPR, requires limiting collection and access to the data strictly necessary for the purpose pursued. Applied to an agent, this principle translates concretely into a tool and data scope defined per task rather than a broad access granted once and for all: an agent tasked with drafting a customer reply does not need read access to the entire payroll database, even if nothing technically prevents it. The temptation, when configuring an agent, is to grant broad access to avoid adjusting it task by task; that is exactly the opposite of what minimization requires, and it is also what turns one isolated configuration mistake into exposure of data at scale. When an agent relies on a platform or a model provided by a third party, that third party most often acts as a processor within the meaning of Article 28 of the GDPR, which requires a contract or data processing agreement specifying the nature, purpose and duration of the processing, as well as the safeguards provided. Checking this agreement before connecting an agent to personal data remains a separate step from the technical review of the tool itself. When that third party or its own subprocessors are located outside the European Union, the general principle for transfers set out in Article 44 of the GDPR applies: a transfer outside the Union requires a recognized mechanism, an adequacy decision, standard contractual clauses or another appropriate safeguard, and this check does not depend on whether the processing is carried out by an agent rather than by conventional software. The rights of data subjects do not disappear because an agent is part of the processing chain. The right of access under Article 15 of the GDPR applies to data an agent has processed just as it applies to data processed by any other system. When a decision produced by an agent has a legal effect or significantly affects a person without real human intervention on that specific decision, Article 22 of the GDPR specifically governs this case: the person has the right not to be subject to a decision based solely on automated processing under these conditions, subject to the exceptions set out in that same article. An agent that drafts a recommendation later reviewed by a person does not fall into this case; an agent whose output becomes the decision without a real review falls into it directly. Article 35 of the GDPR requires a data protection impact assessment when processing is likely to result in a high risk to the rights and freedoms of individuals, notably in the case of systematic evaluation, large-scale profiling or processing of special categories of data. An agent that combines several sources of personal data, acts at scale or influences individual decisions often ticks several of these criteria at once, even when each processing operation taken on its own seemed harmless. The impact assessment then becomes the place to document necessity, proportionality and the measures taken to reduce the risk, before deploying the agent rather than after an incident. #### The AI Act: timeline, risk levels and obligations The AI Act's timeline, Regulation (EU) 2024/1689, has been clarified in several steps. The prohibited practices of Article 5, such as generalized social scoring or certain manipulation techniques, have applied since February 2, 2025. The governance obligations for general-purpose AI models have applied since August 2, 2025. The general date of application under Article 113, which notably covers the transparency obligations of Article 50, remains August 2, 2026. The regulation known as the Digital Omnibus, Regulation (EU) 2026/1744, which entered into force on July 27, 2026, postponed the obligations tied to high-risk systems under Annex III to December 2, 2027, and those for regulated products under Annex I to August 2, 2028. The AI Act classifies systems by their use rather than by their technology. Article 5 bans certain practices regardless of the system used to carry them out. Article 6, combined with Annex III, defines the cases where a system becomes high-risk: recruitment and worker management, access to essential services, creditworthiness assessment, or certain uses in law enforcement and the administration of justice. An agent that automates a recruitment step, for example screening applications before a human interview, can fall into this classification even if it presents itself as a simple decision-support tool; the classification depends on the actual use, not on how the tool is marketed. Article 50 requires clear information to people when they interact with an AI system or receive content it has generated, for the cases it covers. For systems classified as high-risk, Article 14 requires effective human oversight, with a real ability to interrupt the system or discard an output before it produces an effect. This ability to interrupt only holds if a person has the time, the information and the real right to exercise it: a stop button that exists technically but that nobody ever uses, for lack of time to review the agent's outputs before they act, does not satisfy the spirit of this article. Article 3 distinguishes the provider, who develops an AI system and places it on the market or puts it into service under its own name, from the deployer, who uses it under its own authority as part of its activities. A company that builds and markets an agent under its own brand acts as a provider and carries the corresponding obligations, notably documentation ones. A company that uses an agent provided by a third party for its own internal needs generally acts as a deployer, with obligations centered on the use it makes of it, human oversight and informing the people concerned. These two roles do not always exclude each other: the same organization can be a deployer for an agent it buys and a provider for another it develops and makes available to third parties. | Obligation | Date | | Prohibited practices (Article 5) | February 2, 2025 | | General-purpose model governance | August 2, 2025 | | Transparency (Article 50) and general application (Article 113) | August 2, 2026 | | High-risk, Annex III (postponed by the Digital Omnibus) | December 2, 2027 | | High-risk, Annex I, regulated products | August 2, 2028 | #### Check-list before deploying an agent The table below takes each requirement discussed above and sets out the question to ask before deploying an agent on personal data or in a use that could classify it as high-risk, along with the concrete evidence to keep so you can answer a question from a supervisory authority or a client auditing the processing. None of this evidence replaces a full legal analysis: it gives a documented starting point rather than a compliance conclusion. | Requirement | Question to ask | Evidence to keep | | Legal basis (GDPR Article 6) | What legal basis does the agent rely on to process personal data? | The reason documented in the record of processing activities. | | Minimization (GDPR Article 5) | Does the agent have access to more tools or data than its task requires? | The access scope written for each agent or each task. | | Processors and transfers (GDPR Articles 28 and 44) | Does a processing agreement cover the agent's provider, and does a mechanism cover any transfer outside the EU? | The signed data processing agreement or standard contractual clauses. | | Risk classification (AI Act Article 6 and Annex III) | Does the agent's use match a case listed in Annex III? | The classification analysis documented before deployment. | | Human oversight (AI Act Article 14) | Can a person actually interrupt the agent or discard its output before it takes effect? | The interruption procedure and its record of actual use. | | Transparency (AI Act Article 50) | Do the people concerned know they are interacting with an AI system? | The information text shown to the person concerned. | #### What Atipol provides, and what it does not Atipol keeps the history of every ticket and the review decisions that validated it, which gives a record of who requested what and who approved what before an action was integrated. Project content is encrypted under a key specific to the organization, and MCP calls judged sensitive require the explicit approval of the lead agent before execution rather than being executed and logged afterward. Every ticket carries a file scope and acceptance criteria written before the agent is launched, which by construction documents what an agent was allowed to do for that specific task. These elements provide a usable record for documenting real human oversight and a defined access scope, two concrete expectations of the GDPR and the AI Act described above. They do not, however, make an organization compliant with the GDPR or the AI Act, and Atipol replaces neither an impact assessment, nor a lawyer's advice, nor a supervisory authority's decision. Verifying the legal basis of a processing activity, classifying the risk level of a use, or drafting an impact assessment remain decisions that only your organization, with its own counsel, can make. Q: Is an AI agent a processor under the GDPR? A: The agent is a tool; it is the platform or model provider that may be a processor within the meaning of Article 28. Check your contracts and your data processing agreements. Q: Does my agent have to comply with the AI Act if it only automates an internal task? A: Yes: classification depends on actual use, not on whether the agent stays internal to the organization. A use covered by Annex III remains high-risk even internally. Q: Do I need an impact assessment for every agent? A: No, only when the processing poses a high risk under Article 35 of the GDPR, for example large-scale profiling or systematic evaluation of individuals. Q: Have the AI Act's high-risk obligations been cancelled by the Digital Omnibus? A: No, postponed: to December 2, 2027 for Annex III and August 2, 2028 for Annex I. The postponement buys time; it does not remove any obligation. Q: Who is the provider and who is the deployer when using a third-party agent? A: If you develop and market the agent under your own name, you are a provider within the meaning of Article 3. If you use it for your own needs, you are generally a deployer. Q: Does Atipol make my organization compliant with the GDPR and the AI Act? A: No: Atipol documents the scope, the review and the record of human oversight, but it replaces neither a legal analysis nor a compliance decision specific to your organization. Sources: - GDPR, Article 6 (lawfulness of processing): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 5 (data minimization): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 28 (processor): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 44 (general principle for transfers): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 15 (right of access): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 22 (automated individual decision-making): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - GDPR, Article 35 (data protection impact assessment): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679 - AI Act, Article 5 (prohibited practices): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-5 - AI Act, Article 6 (high-risk classification): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-6 - AI Act, Article 3 (provider and deployer): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-3 - AI Act, Article 14 (human oversight): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-14 - AI Act, Article 50 (transparency): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-50 - AI Act, Article 113 (timeline of application): https://ai-act-service-desk.ec.europa.eu/en/ai-act/article-113 - Regulation (EU) 2026/1744, Digital Omnibus, consolidated text of the AI Act: https://eur-lex.europa.eu/eli/reg/2024/1689/2026-07-27/eng/pdf