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 incrementally converts natural-language specifications into typed, effect-aware DAGs through a six-tier type floor hierarchy (TEXT → TYPED → SPEC → STUB → SHIM → PURE). It provides a hybrid LLM/function JIT runtime with three execution modes and a Unix-style CLI toolchain (dagify, dagent, schemagin, datagin). The system addresses context management, latency, reliability, and composability limitations in LLM-based coding agents.

Problem

LLM-based coding agents suffer from unstructured generation that is fragile, context-inefficient, and non-reproducible. Multi-agent settings compound these issues through concurrent edit contention, cascading errors, and token overhead from opaque standards like MCP. Sequential execution prevents parallelism, and existing approaches cannot robustly integrate code generation with data handling and workflow orchestration.

Method

Agint treats code generation as a graph compilation problem. Natural language is compiled into DAG nodes that progress through six type floors: TEXT → TYPED → SPEC → STUB → SHIM → PURE. Three core compilation mechanisms operate on this graph:

  1. Type-Directed Resolution: Each node tracks a RESOLUTION_STATE (UNRESOLVED → FULLY_RESOLVED); transitions preserve semantic equivalence while upgrading representations.
  2. Locality-Preserving Transformation: Node resolution considers only immediate DAG neighborhoods, enabling independent subgraphs to compile concurrently without global synchronization.
  3. Fallback Synthesis: Ambiguous nodes are handled via decomposition, demotion to VIRTUALSHIM (runtime AI synthesis), or deferred compilation.

The hybrid runtime (dagent) supports three JIT modes: Prefine (optimize node code while waiting for upstream inputs), Dynamic (JIT synthesis at VIRTUALSHIM nodes using upstream execution context), and Predict (speculative parallel execution of likely paths). Effect tracking via an effect monad enables safe rollback. The Flyte LLM gateway provides async multi-provider routing; Hydantic decomposes complex structured outputs into parallel sub-model generation calls, yielding 3–10× latency reduction for large structured outputs.

Key Contributions

  • Six-tier type floor system enabling incrementally executable intermediate representations (a TYPED node runs via prompt chaining; a SHIM node blends deterministic code with AI-synthesized virtual functions)
  • Locality-preserving DAG compilation that parallelizes independent subgraph resolution and bounds per-node context to ancestry
  • Hybrid JIT runtime with prefine/dynamic/predict modes and effect-aware rollback
  • Hydantic: hierarchical Pydantic model decomposition for parallel structured output generation (3–10× speedup claimed for multi-field outputs)
  • Unix-style composable toolchain (dagify, dagent, schemagin, datagin) unified via agilink:// URI addressing
  • GUI (Agint Flow) for non-technical users supporting visual DAG editing, conversational refinement, and prototype-to-production promotion

Results

  • No benchmark evaluations against SWE-bench, ML-Bench, or Commit0 are reported; the paper explicitly lists this as future work.
  • Hydantic-backed structured generation yields 3–10× latency reduction for large structured outputs with multiple independent fields (stated without experimental protocol details).
  • All other evidence is via qualitative case studies (ETL pipeline, schema generation, analytics pipeline end-to-end examples).

Limitations

  • No quantitative evaluation against established benchmarks (SWE-bench, ML-Bench, Commit0); comparison to baselines is entirely absent.
  • Primitive type system restricted to str, int, float, bool and their lists; complex data structures require serialization.
  • Scalability tested only to hundreds of nodes; thousands of nodes may hit memory limits during compilation.
  • System effectiveness is directly coupled to underlying LLM quality and provider rate limits; multi-provider routing mitigates but does not eliminate this.
  • The 3–10× Hydantic speedup claim lacks experimental methodology or ablation details.

Relevance to Harnesses / Meta-Harnesses

Agint is architecturally a meta-harness: it does not execute a single agent but compiles, schedules, and orchestrates a DAG of heterogeneous agents and functions, exactly the role a meta-harness plays. Its type floor progression (TEXT → PURE) mirrors the staged pipeline structure common in digest harnesses, where raw inputs are progressively transformed through typed intermediate states. The Flyte LLM gateway with prompt registries, multi-provider routing, and structured output validation is a direct analogue to the provider-abstraction and retry/fallback logic that meta-harnesses typically centralize. The locality-preserving, parallel subgraph execution model offers a concrete design pattern for scaling harness throughput without global context bloat.