Agentic Flow with AMD PACE

Introduction 

AMD PACE (AMD Platform Aware Compute Engine) is an Open source Research and Development (RAD) project and a high-performance inference server that squeezes maximum throughput out of the AMD EPYC™ processor for Transformer workloads. 

With this release, PACE takes its next major step: it graduates from being purely an inference engine to becoming a full agentic AI orchestrator. In this blog we describe why agentic workloads demand a new class of runtime, how PACE now uses LangGraph as its orchestration layer, and the four capabilities that make PACE a platform for building and serving agents:

1. Deterministic Agent Execution and Benchmarking
2. Flexible Deployment Across Local and Remote AI Infrastructure 
3. Native Support for Custom LangGraph Agents
4. Optimized tool ops execution for end-to-end measurable performance gains

You can learn more about AMD PACE at https://github.com/amd/AMD-PACE.

Overview: From Modeling to Reasoning to Agents to Multi-Agents 

Applied AI has climbed a steady ladder of autonomy. It started with modeling - training LLMs to predict the next token, where the goal was one good answer. Next came reasoning, as techniques like chain-of-thought let models break down problems, think through steps, and check their own work. That led to agents: models placed in a loop that can plan, call tools, and take real actions instead of just producing text. Today's frontier is multi-agent systems, where specialized agents - planners, researchers, coders, and critics - work together to solve problems no single agent could handle alone. Every step up this ladder adds capability by running hundreds of connected LLM calls, tool calls, and decisions. PACE now enables orchestration for agentic flow. 

LangGraph

LangGraph has become one of the most popular frameworks for building stateful, controllable agents. Instead of treating an agent as an opaque while-loop, it models the agent as an explicit graph: nodes are units of work (an LLM call, a tool call, a decision); edges define the flow between them. This structure gives developers first-class support for loops, branching, human-in-the-loop interrupts and persistent memory, so a run can be paused, inspected, resumed, or fanned out to sub-agents. That mix of clear structure, and durable state is what makes LangGraph a natural orchestration layer, and it's the foundation PACE builds on.

PACE as an Orchestrator

Originally, PACE optimized every layer of the LLM pipeline - scheduling, KV cache, attention and MLP kernels, to deliver leadership inference performance on AMD EPYC CPUs. That high-performance core stays. 

What's new is the scope: PACE now supports LangGraph as its native orchestration layer, turning it from a single-model inference server into an engine that runs entire agentic graphs end to end. PACE executes the LangGraph state machine, dispatching nodes, routing edges, threading shared state, and managing tool calls, while transparently mapping the LLM calls onto its own optimized backends or external accelerators. The result is one stack that unifies how agents are defined (LangGraph graphs) with how they run efficiently (PACE's platform-aware runtime). Developers write agents in familiar LangGraph, and PACE handles orchestration and scheduling - extending the platform-awareness that made PACE fast for inference into multi-step, multi-agent workflows. Around this orchestration core, PACE focuses on four features.

1. Deterministic Agent Execution and Benchmarking
Agentic systems are hard to debug and reproduce. Because they chain up many LLM calls, tool responses, and branches - each subject to sampling randomness; non-determinism can produce very different runs. This non-determinism leads to inconsistent results, making failures hard to reproduce, and evaluations hard to trust. PACE addresses this with a first-class replay mode: during a run, it records the full trace - graph state, prompts, sampling parameters, tool inputs/outputs, and event ordering, then re-executes the graph against that trace to reproduce the run step-for-step. This makes it easy to reproduce latency, defects and build reliable regression tests by turning agent benchmarking reliable and a repeatable, engineering-grade workflow. Additionally, PACE supports a profiling mode that provides detailed insight into the time spent across different operations in the agentic flow.

2. Flexible Deployment Across Local and Remote AI Infrastructure
PACE can orchestrate agents on CPU while offloading heavy inference to GPUs: PACE can connect to AMD Radeon™ graphics or AMD Instinct™ GPUs running vLLM or other inference serving engines with Open AI compatibility, dispatching model calls to them over the same interface. One can achieve the best of both worlds - PACE's efficient CPU orchestration and deterministic control plane, paired with high-throughput GPU inference, all behind one consistent API.

3. Native Support for Custom LangGraph 
PACE enables bringing your own LangGraph workflows and using our example graphs and reference implementations to build and accelerate agentic applications.

4. Optimized Tool Execution for Agentic Benchmarks
To make agent quality and performance measurable, the current version of agentic workflow supports two leading agentic benchmarks: WebVoyager and GAIA.

WebVoyager tests web-browsing agents on realistic, end-to-end tasks on live websites - searching, navigating, filling forms, and extracting information from dynamic pages, often using a multimodal (screenshot + DOM) view of the browser. It stresses the skills that matter for real-world autonomy: long-horizon planning, robust tool use, and recovery from unexpected page states. Figure 1 shows the normalized time spent on non-LLM operations across page weights (cost of observing a page) and the overhead increases with page weights.