What Is Delegation Depth Limiting for AI Agents?

Connect

Updated on November 2, 2026

Delegation depth limiting is a security control that caps how many times an artificial intelligence (AI) agent can hand off a task, along with its permissions, to another agent before the chain has to stop. You set a maximum number of hops. Once an agent hits that limit, it cannot pass the work along to a new agent. The control exists so you can keep delegation chains short enough to trace, audit, and revoke.

As you deploy more agents that call other agents, delegation chains grow on their own. One agent asks a second agent for help, that agent calls a third, and permissions travel further from the original request with each hop. Depth limiting gives you a way to stop that chain before it outruns your visibility.

Technical Architecture and Core Logic

At the core of delegation depth limiting sits a counter. Every time an agent delegates a task, a credential or token carries that counter forward, and the value increases by one hop. Your policy engine checks the counter against a maximum you define. When an agent tries to delegate past that maximum, the request gets denied and logged.

This isn’t a new idea invented for agents. Request for Comments (RFC) 8693, the Internet Engineering Task Force standard for OAuth 2.0 Token Exchange, defines an “act” claim that records who is acting on whose behalf. Chained “act” claims create a traceable delegation path, similar in principle to how agent depth limits work, though RFC 8693 was written for human and service delegation, not specifically for AI agents. Kerberos constrained delegation follows a related pattern, restricting which services a credential can be forwarded to.

Depth limiting works alongside authenticated delegation, which verifies the identity of each agent in the chain before it acts. Authenticated delegation confirms who is asking. Depth limiting decides how far that asking can travel. You need both. A verified but unlimited chain still leaves you unable to answer a basic question: how many agents touched this task before it finished?

Mechanism and Workflow

The workflow starts when Agent A receives a task it cannot finish alone. Agent A requests permission to delegate part of that task to Agent B. Your system issues a new credential to Agent B, and the depth counter moves from zero to one. If Agent B also needs help, it requests delegation to Agent C, and the counter moves to two.

At each step, three checks happen in sequence:

  • Identity verification: the system confirms which agent is requesting the delegation and which agent will receive it.
  • Depth check: the system compares the current counter against your configured maximum.
  • Scope check: the system confirms the delegated permissions don’t exceed what the original task required.

If any check fails, the request stops there. The agent that hit the limit either finishes the task with its current permissions or escalates to a human for approval. This escalation step matters. Depth limiting isn’t meant to block work outright; it’s meant to force a checkpoint once a chain gets long enough to warrant a second look.

This pattern shows up often in an agent-to-agent (A2A) protocol exchange, where agents built by different teams or vendors communicate directly and each hop needs its own accounting.

Use Cases

You’ll find delegation depth limiting most useful anywhere agents coordinate through multi-step workflows. A customer support agent that triages a ticket, then calls a billing agent, then calls a refund agent, is building a three-hop chain. Without a depth limit, a bug or a bad actor could keep that chain running indefinitely, quietly expanding which systems get touched.

Incident response is another common case. A monitoring agent detects an anomaly, delegates to an investigation agent, which delegates to a remediation agent. Capping that chain at a known depth keeps the blast radius of any single incident response workflow predictable.

Depth limits also matter inside an agentic mesh, where many specialized agents pass work between each other across departments. In that setting, a short depth limit keeps any one task from silently crossing more systems, teams, or data domains than the original request justified.

Limitations

Depth limiting solves one problem. It doesn’t solve every problem in agent delegation. A short chain can still misuse its permissions at any single hop, so you still need scope restrictions and logging at each step, not just a hop count.

Setting the right maximum takes tuning specific to you. A low limit blocks legitimate workflows that genuinely need several hops, like a research agent that consults three specialist agents before compiling an answer. A high limit defeats the purpose of the control. There’s no universal number that fits every organization or workflow, and you should expect to adjust it as your agent workflows mature.

No single standards body currently publishes a recommended numeric depth for AI agent delegation chains. The International Organization for Standardization (ISO) and the National Institute of Standards and Technology (NIST) both address AI risk management broadly, through frameworks like ISO/IEC 42001 and NIST’s AI resources, but neither prescribes a specific delegation depth as of this writing. Treat depth limiting as one control among several, not a complete governance model on its own.

Finally, depth limiting depends on every agent in the chain correctly reporting and forwarding its counter. An agent built outside your policy enforcement, or a third-party agent that doesn’t honor your token format, can break the chain of accounting without you knowing.

Key Terms Appendix

The terms below support the concepts covered in this article.

  • Delegation chain: The sequence of agents or services that pass a task, along with its permissions, from one to the next before the task finishes.
  • Token exchange: A process where one credential is traded for another, often used to pass identity and permission information between agents.
  • Constrained delegation: A restriction that limits which specific services or agents a delegated credential can be forwarded to.
  • Blast radius: The scope of systems, data, or agents that a single task, error, or compromised credential can potentially affect.
  • Policy engine: The system component that evaluates rules, such as depth limits and scope, before approving or denying a delegation request.

You can govern this entire lifecycle from one place. JumpCloud treats human, device, and agent identities as equal members of your environment, giving you a single platform to see, control, and accelerate how agent delegation chains form and behave.

Continue Learning with our Newsletter