An effective agentic workflow also has to be a secure one, because it cannot be allowed to compromise sensitive data access. Agentic workflow architectures need coordination, since they deal with proprietary models and internal systems as well as data, which calls for precise boundaries, authorised identities, isolated memory and end-to-end management.
AI agents can take care of many repetitive tasks, including planning and tool selection, acting on intermediate results as they go. When several work together, they can divide a complex process into specialised responsibilities such as research and code execution.
As discussed in AI Agents for Business, this approach extends automation beyond predefined sequences. However, every additional agent and data source introduces new execution paths and security boundaries.
What is an agentic workflow architecture made of?
An agentic workflow architecture combines model-driven reasoning with deterministic software controls. Models may propose actions, but the surrounding architecture determines whether those actions are permitted and how they are executed.
The pillar sets out the core layers of agent infrastructure. What a multi-agent deployment adds is that each must stay logically separate, with a trust boundary of its own:
- Orchestration: Maintains workflow state and delegates tasks.
- Agent runtime: Executes specialised agents with defined roles and limits.
- Model and tool gateways: Control access to models and external systems.
- Memory: Stores execution state and approved knowledge.
- Policy enforcement: Evaluates permissions and approval requirements.
- Observability: Records actions, errors, costs and performance.
Agents must not bypass security controls simply because they share infrastructure with internal systems. A component reachable directly, without passing through the gateway or the policy layer, is not a boundary at all.
Which coordination pattern should be used?
This is where multi-agent design departs from single-agent deployment, because the pattern determines where policy can be enforced.
A supervisor-worker architecture uses a central coordinator to delegate bounded tasks to specialist agents. It supports centralised policy enforcement, since every delegation passes through one place able to refuse it, at the cost of a single point of failure.
A directed workflow graph defines permitted transitions between tasks, making it suitable for regulated or repeatable processes. Because the paths are declared in advance, the graph doubles as auditable evidence of what the system can do, which matters when an assessor asks.
An event-driven architecture supports asynchronous workflows through queues or event buses, at the cost of handling duplicate messages and inconsistent state. Policy enforcement moves out to each consumer, since no coordinator sees the whole flow.
Whichever pattern applies, communication should use validated schemas carrying task identifiers, agent identities, expected outputs, deadlines and permitted tools. This stops malformed model output from becoming executable instructions, and a message arriving without a declared tool scope should be refused by the receiving agent instead of interpreted generously.
How should agent identities and permissions be managed?
Agents should not share service accounts or inherit the permissions of users initiating workflows. The credential model is covered in our post on running AI agents on private infrastructure; the architectural point here is that identity has to be issued per agent, not per workflow.
This follows NIST Zero Trust Architecture, where “there is no implicit trust granted to assets or user accounts based solely on their physical or network location”. Each agent should receive a short-lived identity limited to its task and tenant, and frameworks such as SPIFFE issue short-lived cryptographic identity documents that workloads use to authenticate to one another. Authorisation is then checked at every resource access, not once at the start of a workflow.
Why should tools be isolated from agents?
Tool execution introduces significant risks, because models may generate incorrect parameters or follow malicious instructions embedded in external content.
Agents should request operations through a controlled gateway that validates inputs and executes only approved actions, enforcing tool allowlists, resource limits, read-only access by default and human approval for consequential operations. Credentials must remain outside model-visible prompts and memory.
The Model Context Protocol security guidance names confused deputy and token passthrough among its attack classes, both turning on authorisation delegated without being independently re-checked. Multi-agent systems reproduce that failure internally: an agent calling another on a user’s behalf must carry a verifiable identity, or the second cannot distinguish an authorised request from a relayed one.
How can prompt injection be contained?
Prompt injection occurs when untrusted content attempts to influence an agent’s behaviour. The NIST Generative AI Profile separates direct injection, where an attacker supplies a malicious prompt to the system, from indirect injection, where instructions are planted in data the system is likely to retrieve. Both sit under information security risk.
Multi-agent systems widen the second case considerably. Malicious instructions can arrive in a retrieved document or a tool response, then travel onward inside a message to an agent with no way of knowing the content was ever untrusted. Containment depends on treating external and model-generated content as data at every hop, and on refusing to let retrieved content alter instructions or permissions. High-impact actions should require explicit approval.
How should memory be designed?
Memory is the part of a multi-agent architecture most often left undesigned. Production systems require several forms of it: temporary execution context, records of previous interactions, organisational knowledge and audit logs. Each needs its own retention period and access controls, so temporary context may expire after execution while audit records are held far longer and kept immutable.
Retrieval permissions must be checked whenever information is accessed. A vector database should return documents only when the requesting agent is authorised to view them, not merely because they match a query. This is the failure that quietly undermines multi-agent pilots: one agent retrieves a document it was never entitled to see, summarises it, and passes the summary to an agent under a different permission set, at which point the original access control no longer governs the derived content.
Shared memory deserves the same scrutiny as a shared database. Where two agents hold different permissions, writing to a common store moves data across the boundary meant to separate them.
How should network and runtime isolation work?
Agents should be isolated according to their responsibilities. A research agent accessing public websites should not have the same network permissions as an agent connected to production databases.
Containerised deployments can use Kubernetes NetworkPolicy to restrict communication and Kubernetes RBAC to control access to cluster resources. One caveat: NetworkPolicy takes effect only where the cluster runs a network plugin that enforces it, so a policy applied without one is silently inert.
Generated code requires particular care and should run in disposable sandboxes without inherited credentials or unrestricted network access. The controls that depend on owning the runtime are set out in the private infrastructure post.
What must be observable?
Multi-agent systems need more than traditional application logs, because identical requests may produce different execution paths. Each workflow should generate a trace connecting agent delegation, model calls, retrieved information, tool operations, policy decisions, errors and resource consumption. The OpenTelemetry tracing model treats a trace as the path of a request through an application, the right unit for a workflow spanning several components.
Observability must also protect sensitive information. Logs should use redacted metadata or identifiers when complete prompts and responses contain confidential data.
How should a multi-agent system be deployed?
Autonomy should be granted in stages, each justified by evidence from the one before it. That path is set out in our post on the sandbox problem, running from synthetic data through to consequential actions gated on human confirmation.
What a multi-agent deployment adds is the evaluation criterion. Evaluation should examine the entire execution path and not just the final response. A correct answer does not justify unauthorised data access or unsafe tool execution, and in a multi-agent workflow that answer is produced several delegations away from where the risk was taken.
Building autonomy within boundaries
Secure agentic workflow architecture establishes where models can make decisions and where deterministic controls must take over.
Models can interpret goals and adapt plans, while the surrounding infrastructure enforces identities, permissions, data boundaries and execution limits.
This separation allows organisations to expand automation gradually while keeping control over increasingly complex multi-agent systems.
Neurotechnology Cloud designs and operates agent environments on dedicated EU-resident capacity through its applied AI solutions practice, with identity and isolation boundaries specified before any agent is given a tool.
If you are designing a multi-agent workflow and working out where the boundaries belong, get in touch.