Agents are already calling your self-service APIs, querying your catalog, and independently provisioning resources around the clock. According to Gartner’s 2026 Hype Cycle for Agentic AI report, agents have had the most aggressive adoption curve of any emerging technology. Gartner even considers agents to be a formal user persona, referring to the agent experience (AX) throughout the report. The question that platform teams are asking has shifted from “Should agents use the platform?” to “How should the platform evolve now that they do?”

For teams using Golden Paths to encode supported development workflows, this shift introduces a new challenge. Paths originally designed to guide human developers must adapt to guide autonomous agents.

In this post, we’ll discuss how to adapt Golden Paths so that agents can use your platform effectively and within constraints. Specifically, we’ll cover the following:

• How to match Golden Paths to the agent’s workload requirements and control boundaries
• How to make the platform capabilities used by Golden Paths machine-consumable and enforceable
• How to turn each Golden Path into a controlled platform workflow

How should you design Golden Paths for AI agents?

An agent-facing Golden Path should be designed around an execution pattern and define which steps must remain under deterministic control.

Match AI agent execution patterns to workload requirements

The term execution pattern describes how and where an agent’s process runs. Platform teams should select an execution pattern based on the workload’s latency, durability, isolation, and API requirements. A Golden Path designed for one execution pattern may suit some workloads but not others.

We recommend that you start by choosing an execution pattern that addresses the workload’s primary constraint. Use a synchronous, low-latency pattern for real-time interactions and a durable pattern for asynchronous or resumable tasks. You can supplement the execution pattern with supporting capabilities as needed, such as an isolated sandbox for development tasks.

You may recognize the underlying principle driving our recommendation. For more than two decades, methods like Attribute-Driven Design, developed by the Carnegie Mellon Software Engineering Institute, have taught engineers to select an execution pattern based on workload requirements. The unique challenge when working with agents is the workload profile, which includes more variable execution time, dynamically selected actions, and potentially greater requirements for durability or isolation.

Real-time conversational AI agents need a low-latency execution pattern

A real-time conversational agent operates within a tight latency budget that typically ranges from seconds to a few minutes. These agents need Golden Paths that use a synchronous, low-latency execution pattern because the agent receives a request, invokes models and tools, and returns or streams a response within a single interaction.

The Golden Path must account for time-to-first-output and total completion time. Streaming reduces the wait for initial output but doesn’t guarantee that the agent will complete its work within the overall latency budget. Low latency and a responsive user experience have always been priorities for synchronous services.

To keep this work within the latency budget, the Golden Path should set an end-to-end deadline, apply timeouts to individual calls, and define what happens if the work cannot finish before the deadline.

Long-running, proactive AI agents need a durable execution pattern

Long-running agents operate asynchronously on tasks that continue for hours or days. Because their work can outlive a single request or application process, the Golden Path should use a durable, resumable execution pattern.

With durable execution, workflow state must persist independently of model context and in-memory agent state to keep the record of the workflow’s progress intact. The record should include completed steps, intermediate outputs, and pending approvals so that work can resume after an application restart or infrastructure interruption.

Add isolated execution when AI agents need to run code

Agents that operate in a development environment inherit that environment’s permissions. Model-generated commands and repository code run with the same access to files, credentials, and network endpoints as the agent process. The Golden Path should isolate these operations from the primary agent service.

When possible, keep the agent harness in a standard, observable service and expose an isolated sandbox as a remote tool. Restrict the sandbox’s filesystem and network access, resource usage, and execution time to fit what the operation requires. The Golden Path should also specify the sandbox’s lifetime and cleanup behavior to prevent state from persisting between runs.

Separate probabilistic agent work from deterministic control

Golden Paths can include probabilistic and deterministic steps. Probabilistic steps allow the agent to perform work that requires interpretation or judgment. Deterministic steps can act as controls by using CI workflows, policy checks, authorization, approvals, and deployment rules to determine whether work can proceed.

When designing an agent-facing Golden Path, identify where agent judgment produces an output that could lead to a consequential action. To reduce the risk of unverified results being executed, place deterministic controls between a probabilistic output and the resulting action.

How can I help AI agents use my platform capabilities?

Golden Paths will tell the agent what to call and when, but they won’t make your platform’s capabilities usable by agents. Each capability’s interface must be legible so that your agent can reason about it independently, and appropriate security measures need to be enforceable at the platform level.

Platform capabilities exposed to agents should have reusable, machine-consumable contracts that define how agents can use them safely. For each workflow, the Golden Path can impose stricter permissions, limits, or approval requirements as necessary. A Golden Path should use authoritative service metadata to determine which resources the agent can act on and which requirements apply. Since guardrails at the orchestration level do not transfer to the capability itself, the platform—not the agent—must enforce both the capability-level contracts and the Golden Path-specific constraints.

Expose capabilities through structured interfaces

Every action exposed to an agent should have a machine-consumable contract that contains the following:

• A clear description
• Typed inputs and outputs
• Stable and versioned schemas
• Machine-readable limits and error categories
• Declared side effects, preconditions, and approval requirements

Rate limits, concurrency limits, execution timeouts, spending limits, and compute or memory boundaries should be enforced at the interface, gateway, or workflow orchestrator. Errors should be machine-readable and differentiate between invalid input, authorization failure, rate limiting, temporary unavailability, and non-retryable policy rejections.

Because agents might repeat a request even after the first attempt succeeds, state-changing operations should be idempotent where possible. When inherent idempotency is not an option, the platform can accept an idempotency key or unique operation identifier so that repeated requests return the original result instead of performing the action again.

Keep the service catalog authoritative for AI agent decisions

Agents can consult wikis and runbooks, but they cannot reliably reconcile information that is incomplete, outdated, or contradictory. An agent-facing Golden Path should be able to direct agents to an authoritative catalog for ownership, dependencies, service criticality, environments, and supported actions.

The Golden Path should verify that required catalog metadata is present and trustworthy before allowing a consequential action to proceed. If that metadata is missing, stale, or contradictory, the path should restrict the agent to read-only operations, require human review, or block the action according to its potential impact.

How can I control autonomous AI agent work?

An agent-facing Golden Path should define the dispatch and workflow controls that govern the majority of autonomous work, including why a run may begin, what the agent may access, where it may execute, and how its results must be recorded.

Make dispatch an explicit step in agent-facing Golden Paths

Dispatch is the platform step that converts a signal into a bounded, authorized agent run. A signal can come from an alert, schedule, code change, human request, or other sources. The signal identifies potential work but doesn’t authorize the agent to perform that work.

Formalize this transition within the Golden Path as: signal → curated context → task identity → allowed capabilities → execution target → recorded output. At the curated-context step, the platform combines authoritative catalog metadata with evidence from the triggering signal. It then assigns a unique task identity that connects the run to its source and enables attribution, deduplication, and audit.

Build checkpoints and retry budgets into AI agent workflows

An autonomous workflow needs explicit points where the platform evaluates progress and determines whether the agent can continue. Build approval states, dry-run or preview modes, and precondition checks into the Golden Path before actions that modify production systems or create other consequential effects.

Bound each correction loop by its number of attempts, elapsed time, cost, or a combination of these factors. Without these limits, an agent can repeatedly consume model, tool, and infrastructure capacity without achieving a successful outcome.

Preserve visibility and accountability in AI agent workflows

An agent-facing Golden Path should define the execution telemetry data and audit evidence that every run must produce. Capture model calls, tool selection, retrieved context, latency, errors, retries, evaluations, and cost.

A trace explains how the agent run unfolded, while an audit event records an action taken against a platform resource. For each external action, record the task identity, credential or workload identity used, and the affected resource, requested operation, approval state, timestamp, and outcome.

Key takeaways: Evolving Golden Paths for AI agents

Golden Paths do not disappear when platform users become agents. They multiply because conversational, long-running, and code-executing agents have different requirements for latency, durability, and isolation. Supporting their execution patterns safely requires machine-consumable capability contracts, authoritative service context, controls enforced outside the agent, and evidence that includes the details of each run. Begin with one bounded path, verify that the agent selects appropriate tasks and operates within its constraints, and then expand its authority incrementally.