AGNT2: Agent-Native Layer 2 Execution
- AGNT2 is a layered execution stack that optimizes high-frequency autonomous agent interactions through a multi-tier architecture and specialized protocol state management.
- It employs a sidecar deployment pattern for zero-code-change onboarding of Docker containerized services while managing identity, escrow, and attestation seamlessly.
- The design integrates fast bilateral channels, dependency-aware sequenced rollups, and an L1 settlement layer with fraud proofs to address throughput and data availability challenges.
AGNT2 is a proposed Layer 2 execution stack for autonomous agent economies in which on-chain activity is dominated not by human-initiated token transfers but by high-frequency, semantically structured service invocations among mutually untrusting principals. It is presented as a three-tier architecture comprising a sidecar deployment pattern for zero-code-change onboarding of containerized services, a bilateral fast path based on peer-to-peer state channels, a dependency-aware sequenced rollup for first-contact and multi-party interactions, and an L1-anchored settlement layer with computational fraud proofs. Its central claim is that existing Layer 2 systems such as Optimism, Arbitrum, and zkSync optimize for generic calldata and therefore place identity, escrow, dependency ordering, and session state above the execution layer at an unfavorable cost point; AGNT2 instead makes those objects first-class protocol state (Ruan et al., 22 Apr 2026).
1. Architectural definition and design rationale
AGNT2 layers an agent-native execution stack above an EVM-compatible L1 in four tiers: a sidecar deployment pattern, Layer Top P2P state channels, Layer Core as a sequenced rollup, and Layer Root settlement with fraud proofs (Ruan et al., 22 Apr 2026). The sidecar runs alongside an existing Docker service and converts service I/O into on-chain interaction transactions. Layer Top provides bilateral sub-100 ms exchanges between established pairs. Layer Core provides dependency-aware sequencing for first-contact and multi-party coordination with a design target of 300 K–500 K TPS and 500 ms–2 s confirmation. Layer Root batches Layer Core state roots to an L1 at an adaptive cadence of 30 s–10 min and supports Type 1 computational fraud proofs and Type 2 channel-state disputes (Ruan et al., 22 Apr 2026).
The architecture is explicitly motivated by the mismatch between human-transaction-oriented rollups and the workload induced by autonomous AI agents. In AGNT2’s framing, agent interactions are semantically rich service invocations whose correctness and economic safety depend on typed execution semantics, per-call escrow, attestation, dependency ordering, and session context, rather than merely on inclusion of opaque calldata. This suggests that the proposed system is not merely an optimization of transaction throughput, but a redefinition of the execution layer around interaction primitives native to agents.
A central organizational distinction is the separation of trust domains across the stack. Layer Top has no sequencer and no DA overhead; its state consists of bilateral channel balances, and settlement occurs only on channel close. Layer Core uses a sequencer that is trusted for liveness but untrusted for correctness; its state is the interaction trie, and outcomes remain provisional until the fraud-proof window closes. Layer Root is the settlement anchor on L1, posting minimal calldata in the form of 32 B hashes while requiring DA commitments before anchoring (Ruan et al., 22 Apr 2026). The paper’s systems focus is correspondingly narrow: sequencing, state, settlement, and the data-availability bandwidth gap.
2. Sidecar deployment pattern and zero-code-change onboarding
AGNT2’s sidecar deployment pattern is designed so that any Docker container can become an on-chain agent without application-code modification (Ruan et al., 22 Apr 2026). The sidecar comprises five modules: a Chain Listener, an Identity Manager, a Payment Engine, an Interaction Router, and an Attestation Engine. The Chain Listener filters INVOKEs addressed to the agent. The Identity Manager handles REGISTER and UPDATE_CAPABILITIES. The Payment Engine tracks escrow, Layer Top channel state, refunds, and settlement. The Interaction Router validates INVOKE, fetches parameters from DA, calls the local service, and manages TTL and retries. The Attestation Engine signs RESPOND payloads, posts them to DA, and emits RESPOND transactions (Ruan et al., 22 Apr 2026).
The interaction flow is described in three steps. First, the caller sidecar posts full parameters to DA and submits INVOKE on Layer Core. Second, the callee sidecar observes the INVOKE, retrieves parameters from DA, calls the container, posts results to DA, and submits RESPOND. Third, the caller sidecar observes RESPOND, fetches the result from DA, and delivers it to the application (Ruan et al., 22 Apr 2026). In effect, the sidecar externalizes chain integration, payment escrow, attestation, and DA plumbing while leaving the original service implementation untouched.
The paper also specifies failure-handling behavior. The sidecar uses a WAL-backed outbox, retries DA posts, promotes channel-path traffic to Layer Core on unresponsiveness, supports graceful TIMEOUT versus strict refund, and configures heartbeat behavior for LLM tail latencies (Ruan et al., 22 Apr 2026). These details are significant because they situate AGNT2 not as a purely abstract protocol design but as a deployment model for existing containerized agent frameworks.
Prototype measurements are reported for zero-code sidecar integration. AutoGen, CrewAI, and LangGraph all ran unmodified, with the following measured interaction counts and p95 latencies (Ruan et al., 22 Apr 2026).
| Framework | Interactions | p95 latency |
|---|---|---|
| AutoGen | 23 intx | 44 759 ms |
| CrewAI | 8 intx | 46 156 ms |
| LangGraph | 6 intx | 3 407 ms |
These measurements do not constitute end-to-end validation of the full Layer Core, which the paper states does not yet exist, but they do validate the claim that existing containerized services can be adapted without code changes.
3. Layer Top and Layer Core: latency classes and dependency-aware execution
Layer Top is the bilateral fast path. Established pairs open a channel on Layer Core and then exchange signed ChannelMessages off-sequencer at sub-100 ms latency (Ruan et al., 22 Apr 2026). The design targets are round-trip latency below 100 ms, 1 000–5 000 TPS per pair, and up to 10 M aggregate TPS across many pairs. CHECKPOINT compresses up to 1 000 interactions into a single Layer Core transaction, and CLOSE_CHANNEL supports cooperative or unilateral settlement with a 4-hour challenge window (Ruan et al., 22 Apr 2026).
Measured channel latencies on Anvil localhost are reported as openChannel at approximately 94 ms, cooperativeClose at 85 ms, and initUnilClose at 84 ms (Ruan et al., 22 Apr 2026). The data also states that ChannelMessage processing costs approximately 0.5 ms per message in sidecar CPU. Aggregate TPS is said to scale linearly with the number of disjoint channel pairs, while per-pair throughput is bounded by CPU and network.
Layer Core is the sequenced rollup for first-contact and multi-party interactions. Its pipeline is given as Mempool → Dependency Analyzer → Batch Builder → Executor → Block Producer (Ruan et al., 22 Apr 2026). Transactions are typed interaction operations including INVOKE, RESPOND, COMPOSE, DISCOVER, TIMEOUT, and channel operations. Each transaction declares dependencies; RESPOND depends on its parent INVOKE, and COMPOSE depends on all constituent INVOKEs. The sequencer then builds an DAG with one edge per declared dependency, plus a small pass adding conservative edges for same-object conflicts (Ruan et al., 22 Apr 2026).
This dependency structure enables parallel execution of independent branches while preserving causal order such as INVOKE → RESPOND and COMPOSE → constituent order. Simulation results report the following sequencer parallelism outcomes (Ruan et al., 22 Apr 2026).
| Workload | Batches | Speedup / parallelism |
|---|---|---|
| mixed-100 | 6 | 3.3× speedup; 16.7× parallelism |
| mixed-1 000 | 9 | 8.1× speedup; 111× parallelism |
| mixed-10 000 | 10 | 39.7× speedup; 1 000× parallelism |
The same section reports that real traces from AutoGen, CrewAI, and LangGraph show 1.2–2.0× practical gains (Ruan et al., 22 Apr 2026). A plausible implication is that the paper distinguishes between the structural parallelism available in synthetic workloads and the smaller but still nontrivial gains observed in existing agent traces.
The Layer Core design target is 300 K–500 K TPS with 500 ms–2 s end-to-end confirmation under optimistic liveness (Ruan et al., 22 Apr 2026). The reported analytical transaction budget is 5–10 s per transaction, giving a single-threaded ceiling of approximately 100,000–200,000 TPS and a 4-worker theoretical ceiling of approximately 400,000–800,000 TPS. However, the paper classifies this 300–500 K TPS Layer Core ceiling as design-only and states that the prototype is pending (Ruan et al., 22 Apr 2026).
4. Settlement model, fraud proofs, and interaction-state semantics
Layer Root batches Layer Core state roots to L1 and runs two forms of dispute resolution: Type 1 computational fraud proofs and Type 2 channel disputes (Ruan et al., 22 Apr 2026). Root posting occurs at an adaptive cadence of 30 s–10 min. The Type 1 settlement latency components are listed as DA blob fetch at 1–5 min, re-execution at at most 1 min, proof construction under 1 min, and L1 inclusion at at most 5 min, for a total worst-case of approximately 8–12 min; the safety window is set to 1 hour, which the paper describes as roughly a 5× margin (Ruan et al., 22 Apr 2026).
The computational fraud proof uses interactive bisection to one AGNT2 VM step (Ruan et al., 22 Apr 2026). Reported witness sizes are approximately 1.1 KB in a native environment versus at least 2–5 KB on EVM, and verifier gas is approximately 30–80 K gas native versus approximately 200–500 K gas on EVM (Ruan et al., 22 Apr 2026). The paper also reports that root posting costs approximately 50 K gas per root.
The state model underlying these proofs is the interaction trie. Its root is the Merkle root of a trie with namespaces /agents, /channels, /interactions, /disputes, and /global (Ruan et al., 22 Apr 2026). Each /agents/{agent_id} node holds identity, economics, stake, capabilities, reputation counters, session states, channel references, and an interaction_history_root (Ruan et al., 22 Apr 2026). This structure makes identity, reputation, capabilities, session context, and micropayment channels first-class protocol objects rather than application-layer conventions.
The paper describes several first-class objects in more detail. Identity is an ERC-8004-compatible superset. Capabilities record schema hashes, endpoint, price, and average latency. Reputation is a deterministic score derived from counters including completed, timeout, disputed, lost, and diversity weight. Session context is maintained as per-session state machines. Micropayment channels are represented as per-channel sub-accounts (Ruan et al., 22 Apr 2026). These definitions matter because AGNT2’s core thesis is not solely about throughput; it is also about the internal representation of service-oriented execution semantics.
State transitions are similarly typed. INVOKE locks escrow and creates a pending record. RESPOND releases escrow, updates reputation, and attaches attestation. TIMEOUT refunds the caller and penalizes the callee. COMPOSE provides atomic grouping of INVOKEs and RESPONDs with sub-escrow and rollback. DISCOVER is an on-chain query by capability or filter. REGISTER, DEREGISTER, UPDATE_CAPABILITIES, OPEN_CHANNEL, CLOSE_CHANNEL, CHECKPOINT, and DISPUTE are also explicit operations (Ruan et al., 22 Apr 2026). Composition semantics are defined so that sub-invocation escrow is held until full success and rollback discards all tentative state (Ruan et al., 22 Apr 2026). Foundry tests T4–T9 are reported to verify invalid signature revert, timeout reclaim, and escrow rollback (Ruan et al., 22 Apr 2026).
5. Performance claims, empirical measurements, and the DA bottleneck
AGNT2 distinguishes sharply between simulated, analytical, measured, and design-only results. This distinction is essential for interpreting the paper’s quantitative claims. Some selected measurements validate components such as sidecar integration, channel open/close latency, unilateral close, and atomic COMPOSE settlement, while the full Layer Core remains unimplemented (Ruan et al., 22 Apr 2026).
Measured escrow gas cost is reported as:
with and, at 1 gwei, corresponding to \$3.29 (Ruan et al., 22 Apr 2026). The sidecar crash-recovery unilateral close path reports finalizeUnilateralClose at 68 722 gas, and a 24-hour test in Anvil passes (Ruan et al., 22 Apr 2026).
The principal systems constraint identified by the paper is data availability. Each completed interaction writes two 1 KB blobs, one for INVOKE and one for RESPOND, yielding 2 KB total DA write (Ruan et al., 22 Apr 2026). After assuming that 65% of interactions are offloaded to Layer Top, 35% remain on DA (Ruan et al., 22 Apr 2026). At the 500 K TPS target, the paper gives the resulting DA requirement as approximately 1 GB/s (Ruan et al., 22 Apr 2026).
Current backends are reported as Celestia at approximately 6 MB/s, saturating at approximately 6 144 TPS, and EigenDA at approximately 10 MB/s, saturating at approximately 10 240 TPS (Ruan et al., 22 Apr 2026). On this basis, AGNT2 characterizes the near-term practical regime as 10 K–100 K TPS and describes deployment as DA-bound, with a roughly 100× gap relative to the target ceiling (Ruan et al., 22 Apr 2026).
| DA backend or regime | Throughput figure | Consequence |
|---|---|---|
| Celestia | ~6 MB/s | ~6 144 TPS |
| EigenDA | ~10 MB/s | ~10 240 TPS |
| AGNT2 near-term regime | 10 K–100 K TPS | DA-bound |
| Full 500 K TPS target | ~1 GB/s DA demand | Requires purpose-built Agent-DA |
This quantitative asymmetry is the paper’s most important limitation claim. AGNT2 argues for a dedicated execution layer for agent economies, but the presented architecture remains bounded by DA throughput rather than by the rollup scheduler or channel design. A plausible implication is that the viability of the full design depends at least as much on DA specialization as on execution-layer innovation.
6. Research status, interpretive significance, and open problems
The paper states that simulation and analytical modeling support the architecture and that prototype measurements validate selected components, but that no end-to-end Layer Core implementation exists yet (Ruan et al., 22 Apr 2026). This places AGNT2 in a mixed evidentiary category: part systems prototype, part architectural proposal, and part analytical capacity study.
Its primary findings are summarized as follows. Human-transaction-optimized Layer 2 systems lack native service-invocation semantics such as dependency ordering, per-call escrow, attestation, and session state. The sidecar pattern enables zero-code-change onboarding of existing containerized services. The three-layer stack of P2P channels, dependency-aware sequenced rollup, and settlement with fraud proofs is intended to match agents’ latency and trust granularity. The interaction trie elevates identity, reputation, capabilities, and composition history to protocol state (Ruan et al., 22 Apr 2026).
The paper also lists explicit open research questions and next steps. These include full implementation of the Layer Core typed VM and distributed sequencer, a purpose-built agent-optimized DA layer with regional sharding and retention, formal serialization-equivalence proof and VM semantics, cryptoeconomic design for stake parameters, gas weights, and the reputation formula, qualitative fraud adjudication for LLM semantic correctness and governance, and Phase 3 BFT or shared-sequencer deployments together with an L1-native agent VM (Ruan et al., 22 Apr 2026).
Several possible misconceptions are preempted by the paper’s own scope statements. AGNT2 is not presented as an already deployed high-throughput agent chain; practical deployment is currently constrained to approximately 10 K–100 K TPS by DA throughput (Ruan et al., 22 Apr 2026). Nor is it simply a payment-channel network, because Layer Top is only one latency class within a broader typed execution environment centered on an interaction trie and dependency-aware sequencing. Conversely, it is not merely a new agent framework; its core proposition is infrastructural, namely that autonomous agent economies require execution semantics different from those of general-purpose chains repurposed for agents (Ruan et al., 22 Apr 2026).
Taken together, these claims define AGNT2 as a proposal for interaction-optimized Layer 2 infrastructure in which service invocation, escrow, attestation, dependency order, and session state are protocol-native objects. The architecture’s significance lies less in a completed implementation than in its explicit reframing of blockchain execution around autonomous agents as economic actors rather than around users as transaction initiators (Ruan et al., 22 Apr 2026).