Skip to content

Agint: Agentic Graph Compilation for Software Engineering Agents

🕒 Published (v1): 2025-11-24 19:10 UTC · Source: Arxiv · Venue: NEURIPS 2025 · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

Agint is an agentic graph compiler that transforms natural-language software specifications into executable code via a six-tier typed DAG representation (TEXT→TYPED→SPEC→STUB→SHIM→PURE). It introduces a hybrid LLM/function JIT runtime with three execution modes and a Unix-style toolchain, enabling parallel, reproducible, and incrementally refinable code generation for software engineering agents.

Problem

LLM-based coding agents suffer from poor context management, high latency, unreliability, and lack of composability—especially in multi-agent or multi-developer settings. Concurrent edits cause cascading errors, monolithic generation is fragile, and there is no principled mechanism for parallelizing subgraph execution or maintaining reproducibility across non-deterministic LLM calls.

Method

Agint compiles NL specifications into effect-aware DAGs through a six-floor type hierarchy: TEXT → TYPED → SPEC → STUB → SHIM → PURE. Each node carries a RESOLUTION_STATE and advances through specialized resolvers (e.g., PlainToTypedResolver, TypedToSpecResolver). Three mechanisms govern compilation: (1) type-directed resolution that preserves semantic equivalence across floors; (2) locality-preserving transformation where each node only requires its neighborhood context, enabling parallel independent subgraph compilation; and (3) fallback synthesis via node decomposition, VIRTUALSHIM nodes, or deferred passes. The hybrid runtime (dagent) supports three JIT modes—prefine (optimize before input arrives), dynamic (JIT synthesis at VIRTUALSHIM nodes using upstream context), and predict (speculative parallel execution of likely paths). Effect tracking via an effect monad enables rollback of filesystem/network/database side effects. The Flyte LLM gateway uses Hydantic (hierarchical Pydantic decomposition) to parallelize structured-output generation with focused per-branch prompts, claiming 3–10× latency reduction for outputs with many independent fields. The toolchain consists of dagify (DAG compiler), dagent (runtime), schemagin (NL→DB schema), and datagin (data ingest/transform/synthesis), unified via an agilink:// URI addressing layer.

Key Contributions

  • Six-floor typed intermediate representation (TEXT→TYPED→SPEC→STUB→SHIM→PURE) where each floor is executable, enabling incremental development without waiting for full compilation.
  • Locality-preserving DAG compilation that restricts each resolver's context to node neighborhoods, supporting parallel subgraph compilation without global synchronization.
  • Hybrid JIT runtime with three execution modes (prefine, dynamic, predict) and effect-aware rollback via an effect monad.
  • Hydantic: hierarchical Pydantic model decomposition that parallelizes structured-output generation, reducing per-call context and latency.
  • Composable Unix-style toolchain (dagify, dagent, schemagin, datagin) with shared CLI conventions and agilink:// typed URI abstraction.
  • Compile targets for external frameworks (CrewAI, LangChain, WDL, BAML), enabling interoperability with existing agent ecosystems.

Results

  • No quantitative benchmark evaluation is presented; the paper explicitly acknowledges evaluation against SWE-bench, ML-Bench, and Commit0 as future work.
  • Claims 3–10Ă— latency reduction for structured output generation via Hydantic parallel subcalls (no controlled experiment provided; stated as a design property).
  • System tested on workflows with "hundreds of nodes"; behavior at thousands of nodes is untested.

Limitations

  • No empirical evaluation against established benchmarks (SWE-bench, ML-Bench, Commit0); all results are qualitative or via example.
  • PrimitiveType system restricted to str, int, float, bool and their lists; complex data structures require serialization.
  • Performance degrades under LLM rate limits or when models lack domain-specific knowledge; multi-provider routing mitigates but does not eliminate this.
  • Scalability untested beyond hundreds of nodes; memory constraints expected at thousands of nodes.
  • No open-source code release; reproducibility relies on proprietary hosted services.

Relevance to Agentic AI / LLM Agents

Agint directly addresses a core unsolved problem in agentic software engineering: making LLM-driven code generation reliable, reproducible, and parallelizable at scale. By framing agentic code generation as a compiler problem with typed intermediate representations, it offers a principled alternative to monolithic prompt-based agents, with explicit concurrency safety and effect-aware rollback. The locality-preserving DAG structure is a practical mechanism for context management in long-horizon agentic tasks—a known bottleneck for current agents. The hybrid runtime's ability to delegate subproblems to smaller/faster models while reserving larger models for compilation planning is directly relevant to cost-efficient multi-model agent architectures.