Agentic Computation Graphs

• ACGs are defined as typed, executable workflow graphs where nodes perform atomic LLM actions, retrievals, and tool invocations with clear data and control dependencies.
• They separate reusable workflow templates from realized graphs and execution traces, enabling offline, pre-execution, and in-execution structural optimization.
• ACGs unify diverse systems across multi-agent orchestration, scientific automation, and software engineering by providing explicit graph semantics and process transparency.

Searching arXiv for papers on Agentic Computation Graphs and closely related frameworks. Agentic Computation Graphs (ACGs) are executable, LLM-centered workflow graphs in which nodes perform atomic actions—LLM calls, retrieval, tool invocation, code execution, memory updates, verification, or message passing—and edges encode control, data, or communication dependencies. In the survey literature, ACGs make workflow structure itself the primary object of design, optimization, and evaluation, and it is useful to distinguish a reusable template $T=(\mathcal V,\mathcal E,\Phi,\Sigma,\mathcal A)$, a realized graph $G_x = Inst(T,x;\pi)$ for a specific input, and the execution trace $$\xi_x = Exec(G_x;\mathcal E)=\{(s_t,a_t,o_t,c_t)\}_{t=1}^T$$ that records runtime behavior (Yue et al., 23 Mar 2026).

1. Core definition and representational layers

The survey treatment of ACGs defines them as typed, directed graphs whose nodes perform atomic actions and whose edges specify how information and control propagate. Typical node types include LLM calls, retrieval, tool use, code execution, memory update, verifier/checker, and message passing; typical edge labels distinguish dataflow, control, and communication. In multi-agent systems, nodes may denote heterogeneous agent roles with distinct prompts, tools, or models, while edges represent messages or coordination links rather than only data dependencies (Yue et al., 23 Mar 2026).

A central conceptual distinction is between reusable workflow structure and run-specific behavior. A template fixes the operator library, parameters, scheduling or routing policy, and admissible edit actions. A realized graph is the workflow actually instantiated for a particular input, and an execution trace is the sequence of state transitions, actions, observations, and costs produced when that realized graph interacts with an environment. This separation is important because many apparent disagreements in the literature concern different levels of description: some methods optimize templates offline, some generate realized graphs before execution, and some edit structure during execution itself (Yue et al., 23 Mar 2026).

The same survey organizes ACG research along three orthogonal axes: when structure is determined, what part of the workflow is optimized, and which signals authorize optimization. “Graph Determination Time” distinguishes offline template search, pre-execution graph construction, and in-execution structural revision. “Graph Plasticity Mode” distinguishes fixed graphs from systems that select, generate, or edit structure. Optimization targets can include node-level components, topology, scheduling, memory and caching, or verification loops, while guidance signals can come from task metrics, verifier outputs, preference models, or trace-derived feedback (Yue et al., 23 Mar 2026).

This taxonomy clarifies why ACGs unify otherwise disparate systems. A graph-based chemistry pipeline, a multi-agent quantitative research assistant, a software-engineering compiler-runtime stack, and a reactive event-sourced agent substrate can all be described as ACGs if their computations are explicit graph transformations with typed nodes, typed edges, and observable execution traces.

2. Formal semantics and computational regimes

Theoretical work on Quest Graphs provides a computability-oriented lens for ACGs by modeling agents with finite local context and explicitly separating hierarchical control from externalized memory. In that framework, the base Quest Graph is equivalent to an unrestricted Turing machine; the forward-only Finite Quest Decision Process (FQDP) is equivalent to a pushdown automaton and therefore context-free; and the Reference-Augmented QDP (RQDP) regains Turing completeness only when stateful queries are allowed over a non-finite reference space (Viriyasuthee, 26 Jan 2026).

This hierarchy makes a precise claim about agentic structure. Forward-only hierarchical expansion without stateful external references is powerful enough for stack-disciplined recursion but not for general computation. Once an ACG includes stateful retrieval keyed by a non-finite address space, the system can simulate arbitrary Turing computation and can do so much more efficiently on dependency-dense computation graphs. The same paper shows that this distinction is not merely expressivity-theoretic: reference-augmented systems can be exponentially more efficient than non-augmented systems when simulating complex graphs, because memoized reuse eliminates the repeated recomputation inherent in purely context-free control (Viriyasuthee, 26 Jan 2026).

A common misconception is that ACGs are synonymous with DAGs. Many influential implementations do enforce DAG structure, but the broader concept is not limited to acyclic graphs. GraphBit defines an ACG explicitly as a directed acyclic graph with typed nodes and typed edges, and ATG likewise uses an executable DAG with interface-preserving recursive refinement (Sarker et al., 8 Mar 2026). By contrast, Graphectory is defined as a cyclic, directed computation graph over temporal and structural edges for software-agent trajectories, and RewardFlow constructs a general directed state graph from multiple trajectories, with cycles handled naturally by backward multi-source BFS (Liu et al., 2 Dec 2025, Feng et al., 19 Mar 2026). ActiveGraph adopts a typed directed multigraph as the working state projected from an append-only event log (Nakajima, 21 May 2026).

This variety suggests that acyclicity is a design choice tied to a system’s guarantees rather than a universal defining property of ACGs. DAG-based ACGs emphasize termination, deterministic scheduling, and local repair. Cyclic or reactive ACGs emphasize trajectory analysis, iterative behavior, or event-driven coordination.

3. Execution models, control flow, and repair

GraphBit offers one of the most explicit execution semantics for DAG-based ACGs. It defines $G=(V,E)$ with three node kinds: agent nodes as LLM-driven reasoning units with declared schemas and optional tool sets, tool nodes as deterministic functions, and control nodes for conditionals, fan-out, and aggregation. Workflow state is a typed key–value store $S$, and control flow is governed by typed predicates $p_{i,k}:S\to\{\text{true},\text{false}\}$ rather than by free-form LLM generations. Parallel fan-out occurs when several outgoing predicates evaluate to true; joins merge branch states via a user-defined function $\mu:S^m\to S$; cycles are rejected at graph construction time; and runtime scheduling uses a topological, event-driven ready queue with typical complexity $O(|V|+|E|)$ (Sarker et al., 8 Mar 2026).

ATG uses a related DAG substrate but emphasizes graph evolution. It begins with a coarse task node, recursively refines non-atomic nodes into subgraphs while preserving their external interfaces, records the evolution sequence $\{G_0,G_1,\ldots,G_T\}$, and executes the final atomic DAG by dependency-aware scheduling. When failures occur, ATG identifies the lowest common historical ancestor of the failed region, freezes validated nodes outside the affected subgraph, and repairs only the minimal necessary subgraph while reusing cached outputs from unaffected regions (Zhang et al., 2 Jul 2026).

A different control philosophy appears in Agent Harness. There, “Agentic Programming” puts all looping, branching, and sequencing into ordinary program control, while the LLM is invoked only at typed call sites for reasoning or generation. The paper states that the execution history becomes a call graph, a DAG of function and reasoning nodes, and that a call sees the full context of its ancestor chain while each frame keeps only summaries of returned children. The resulting context length is bounded by call depth, $O(\text{depth})$, rather than by the total number of steps, $G_x = Inst(T,x;\pi)$0 (Qi et al., 14 Jun 2026).

ActiveGraph departs from imperative orchestration entirely. Its append-only event log is the source of truth, the working graph is a deterministic projection of that log, and behaviors react to graph deltas by emitting new events. No component instructs another directly; coordination emerges from shared graph subscriptions and typed relation-behaviors. The runtime therefore defines execution as deterministic fold plus reactive scheduling rather than as a conversation loop or topological task queue (Nakajima, 21 May 2026).

Across these systems, explicit graph structure serves three recurrent purposes. First, it fixes or constrains control flow so that transitions are not hallucinated. Second, it isolates units of execution so that failures can be localized. Third, it exposes dependency structure for concurrency, memoization, or replay.

4. State, memory, and provenance

State management is a defining fault line among ACG implementations. GraphBit’s three-tier memory architecture separates ephemeral scratch space, structured state $G_x = Inst(T,x;\pi)$1, and external connectors. Scratch is transient and per-node; structured state is a typed, compact, canonical context with atomic updates and scoped reads and writes; connectors cover databases, vector stores, web search, APIs, and file systems, but their results are not automatically injected into prompts or global state. On GAIA tasks, this architecture is tied to concrete efficiency gains: mean token consumption per task is 1,916 for GraphBit, compared with 6,276 for Pydantic AI and 13,638 for CrewAI. Its memory ablations report accuracy drops of $G_x = Inst(T,x;\pi)$2 points without scratch, $G_x = Inst(T,x;\pi)$3 without structured state, $G_x = Inst(T,x;\pi)$4 without external connectors, and a single-tier baseline accuracy of 52.9% with memory doubled to $G_x = Inst(T,x;\pi)$5 (Sarker et al., 8 Mar 2026).

Agent Harness reaches a similar end through call-graph scoping rather than explicit memory tiers. The parent frame keeps only a one-line summary of a returned child subtree, and stack unwinding prevents the entire intermediate transcript from being re-fed at later steps. This is presented as an architectural alternative to shared mutable orchestration state (Qi et al., 14 Jun 2026).

Scientific ACGs push externalization further. El Agente Gráfico represents computational state as typed Python objects, persists heavy state in an RDF knowledge graph, and uses IRIs as symbolic handles for molecules, conformers, mean-field states, TDDFT outputs, MOF structures, and other artifacts. The object-graph mapper serializes and restores typed objects with strict type enforcement and lazy loading, while SPARQL queries and ontology snapshots make the knowledge graph both memory and reasoning substrate (Bai et al., 19 Feb 2026).

ActiveGraph makes provenance primary rather than ancillary. Each event record carries an id, type, payload, actor, caused-by pointer, version metadata, and request hash; the working graph is a deterministic fold over these events; and replay uses content-addressed caches for model and tool calls. This design yields deterministic replay of any run from its log, cheap forking at any event without re-executing the shared prefix, and end-to-end lineage from goals to individual model calls (Nakajima, 21 May 2026).

These systems share a common design pressure: long-horizon agents degrade when raw textual context accumulates indiscriminately. ACGs respond by storing less in prompts and more in typed state, logs, or external graph substrates.

5. Evaluation, optimization, and process analysis

The survey literature argues that downstream task accuracy is not sufficient for comparing ACGs. It recommends reporting graph-level properties such as node count, edge count, depth, branching factor, critical path length, concurrency, communication volume, edit count, structural variance across inputs, and cost-per-success, while separating template-level choices, realized graphs, and execution traces in evaluation protocols (Yue et al., 23 Mar 2026).

GraphBit provides one of the clearest benchmark-driven demonstrations. On 68 GAIA tasks, it reports 67.6% accuracy, 0% framework-induced hallucinations, 11.9 ms mean processing overhead, 5,025 ops/min throughput, and 126.1 MB peak memory, with cross-platform reproducibility of 67.4–67.9% accuracy and standard deviation 0.3%. On web-enabled tasks, it reports 69.0% accuracy with 0% hallucination, contrasted with 69.0% hallucination for LangGraph on web tasks (Sarker et al., 8 Mar 2026).

For workflow optimization, the FLORA-Bench position paper models agentic workflows as DAGs and uses GNN surrogates to predict workflow performance without repeated LLM execution. FLORA-Bench contains 600k workflow–task pairs with binary labels across coding, mathematics, and reasoning. When a GCN predictor is integrated into AFLOW’s optimization loop, the paper reports average $G_x = Inst(T,x;\pi)$6 acceleration of refinement cycles relative to ground-truth evaluation, with average performance loss $G_x = Inst(T,x;\pi)$7 and improvement over a random predictor by $G_x = Inst(T,x;\pi)$8 average score (Zhang et al., 14 Mar 2025).

RewardFlow treats an ACG as a state graph assembled from multiple trajectories of the same task instance. It computes shortest-hop distances from success terminals, assigns each canonical state the potential $G_x = Inst(T,x;\pi)$9, and shapes action rewards by potential difference $$\xi_x = Exec(G_x;\mathcal E)=\{(s_t,a_t,o_t,c_t)\}_{t=1}^T$$0. Integrated into PPO-style RL, this topology-aware propagation yields substantial gains across ALFWorld, WebShop, Sokoban, and DeepResearch; for example, on ALFWorld with Qwen2.5-7B it reports 89.8% versus 82.8% for GiGPO, and on Sokoban with Qwen2.5-VL-7B it reports 62.4% versus 34.4% (Feng et al., 19 Mar 2026).

Process-centric analysis extends evaluation from graphs of planned computation to graphs of realized behavior. Graphectory defines metrics such as Node Count, Temporal Edge Count, Loop Count, Average Loop Length, Structural Edge Count, and Structural Breadth over trajectories of software agents. On 4,000 trajectories from SWE-agent and OpenHands, it shows that stronger models and richer prompts produce more complex graphs with broader exploration and more validation, while unresolved trajectories exhibit more shortcuts, backtracks, loops, and anti-patterns (Liu et al., 2 Dec 2025).

A plausible implication is that ACG evaluation is moving from single-number leaderboard performance toward multi-level analysis: graph structure, runtime cost, process quality, robustness, and structural variance all become first-class empirical objects.

6. Representative system families and application domains

The present literature spans a wide range of domains, but the recurring pattern is the same: explicit graph structure becomes the substrate for planning, execution, memory, and evaluation.

System	Domain	Defining ACG characteristic
GraphBit	General multi-agent orchestration	Typed DAG with engine-governed routing and three-tier memory
HypoAgent	Interactive abductive reasoning over knowledge graphs	IRA → HGA → RCAA graph with diagnosis-refinement loops
ChemGraph	Computational chemistry and materials science	LangGraph-based DAG over planners, executors, aggregators, and validators
El Agente Gráfico	Scientific automation	Typed execution graph plus persistent knowledge graph memory
QRAFTI	Quantitative finance	Tool-grounded DAGs over panel data with reflection-driven replanning
Agint	Software engineering	Typed, effect-aware code DAGs with explicit type floors
ATG	Interactive benchmark tasks	Recursive DAG compilation, parallel execution, and minimal subgraph repair
ActiveGraph	Auditable agent infrastructure	Event-sourced reactive graph with deterministic projection

HypoAgent is a concise example of an interactive, dynamically routed ACG. It consists of an Intent Recognition Agent that grounds dialogue into executable knowledge-graph conditions, a Hypothesis Generation Agent that produces and executes first-order logic hypotheses, and a Root Cause Analysis Agent that diagnoses unreliable fragments and proposes refinements. Routing to diagnosis is conditional on similarity scores such as Jaccard dropping below a threshold, and the graph supports iterative diagnosis-refinement loops across turns (Gao et al., 29 May 2026).

ChemGraph operationalizes ACGs in computational chemistry by representing every workflow as an explicit computation graph over planner nodes, Python tool adapters, aggregators, and response or structured-output nodes. It uses LangGraph’s state-node-edge execution model and heterogeneous backends including xTB, ML interatomic potentials such as MACE and UMA, and ab-initio codes via ASE calculators. On 13 benchmark tasks, it reports that multi-agent decomposition can raise GPT-4o-mini from 0.17 to 0.77 on react2enthalpy and from 0.20 to 0.93 on react2gibbs, while Claude-3.5-haiku rises from 0.80 to 0.97 on react2gibbs (Pham et al., 3 Jun 2025).

QRAFTI instantiates ACGs for empirical finance by compiling natural-language research requests into explicit factor-construction DAGs over MCP tools and, when needed, dynamic Python code. On multi-step workflows, all-tools without reflection reaches Sim@1 $$\xi_x = Exec(G_x;\mathcal E)=\{(s_t,a_t,o_t,c_t)\}_{t=1}^T$$1, while adding reflection raises Sim@1 $$\xi_x = Exec(G_x;\mathcal E)=\{(s_t,a_t,o_t,c_t)\}_{t=1}^T$$2 and Sim@2 $$\xi_x = Exec(G_x;\mathcal E)=\{(s_t,a_t,o_t,c_t)\}_{t=1}^T$$3; the framework also logs typed computation traces and standardized reports with node-level provenance (Lim et al., 20 Apr 2026).

Agint recasts software-engineering workflows as typed, effect-aware code DAGs. Its nodes carry explicit type floors—TEXT, TYPED, SPEC, STUB, SHIM, PURE—together with type signatures, effect annotations, and resolution states. Compilation is incremental and hierarchical, while runtime scheduling is effect-aware and can use speculative execution or JIT synthesis at SHIM nodes (Chivukula et al., 24 Nov 2025).

Taken together, these systems show that ACGs are not restricted to one orchestration ideology. Some center engine-level determinism, some emphasize typed scientific state, some emphasize graph compilation from natural language, and some make the event log or process graph the primary object.

7. Limitations, misconceptions, and open problems

A common misconception is that making workflow structure explicit eliminates the major failure modes of agentic systems. The current literature does not support that claim. GraphBit still requires explicit DAG specification and typed schemas, and its paper identifies connector brittleness, large-DAG dependency management, and the inability to natively represent dynamic self-modification or cycles as current limitations (Sarker et al., 8 Mar 2026). ATG similarly depends on the backbone model’s decomposition ability, incurs extra overhead on simple tasks, and has been evaluated only on text-based interactive benchmarks rather than broader multimodal or real-world environments (Zhang et al., 2 Jul 2026).

The scientific systems reveal another constraint: graph structure does not remove infrastructure complexity. El Agente Gráfico emphasizes resource coupling, global GPU-context management, heterogeneous software brittleness, and provider-side cache TTL hazards even in a strongly typed, KG-backed execution environment (Bai et al., 19 Feb 2026). ActiveGraph, for its part, treats multi-agent contention in distributed or multi-writer scenarios as outside scope and requires stable total ordering or deterministic reduction from partial orders to preserve replay guarantees (Nakajima, 21 May 2026).

Optimization results also highlight a generalization gap. In FLORA-Bench, cross-system and cross-task generalization of GNN surrogates drops markedly, with accuracies often around 0.48–0.62 outside the training distribution. This suggests that structure-aware optimization is effective in-domain but not yet distributionally robust across heterogeneous ACG families (Zhang et al., 14 Mar 2025).

Security evaluation introduces a further corrective. AgentSeer decomposes agent runs into action graphs and component graphs and shows that agentic-level vulnerabilities can differ fundamentally from model-level ones. The paper reports “agentic-only” vulnerabilities that emerge only in deployed agentic settings, with tool-calling showing 24–60% higher ASR across two evaluated models and agent transfer operations forming the highest-risk tool category (Wicaksono et al., 5 Sep 2025). This suggests that graph explicitness improves observability and diagnosis, but also exposes new attack surfaces at tool, memory, and delegation edges.

The survey literature frames the resulting open problems in structural terms: structural credit assignment, expressivity versus verifiability, continual adaptation under tool and environment drift, benchmark quality and canonicalization, and theory for when static templates suffice versus when dynamic generation or editing is necessary (Yue et al., 23 Mar 2026). In that sense, ACGs have become both an engineering pattern and a research program: they turn agent structure into a manipulable object, but they also force precise questions about which structures are computable, auditable, efficient, generalizable, and safe.