# Beyond A2A: How Rust-Powered Shared State Machines Turn Agent Protocols Into Executable Infrastructure

*Protocols define how agents talk, GI shows how they act*

By [General Impression](https://paragraph.com/@gi) · 2025-04-16

a2a, ai, rust, mcp, gi, infra

---

Rethinking Agent Collaboration: From Schema to Runtime
------------------------------------------------------

Protocols like Google’s A2A (Agent-to-Agent) and Anthropic’s MCP (Model Context Protocol) have begun to standardize how agents communicate and access tools. However, most current implementations treat these schemas as abstract interfaces—relying on stateless message-passing systems, disconnected execution layers, and external orchestration logic.

At General Impressions (GI), we believe this approach misses the critical point: multi-agent systems need more than a schema. They require a coherent runtime that can execute these structures efficiently, verifiably, and across both local and remote contexts.

Our answer is the Shared State Machine: a Rust-native execution layer that unifies agent collaboration, memory, and lifecycle management into a single programmable substrate.

The Shared State Machine: Execution as Communication
----------------------------------------------------

In GI, agent coordination is not abstracted away in queues or black-box middleware. Instead, it is made explicit through a **Shared State Machine**:

*   Every agent is modeled as a finite-state process
    
*   All coordination is encoded as state transitions within a global state graph
    
*   Transitions are composable, deterministic, and persistently recorded
    

This allows agents to not just talk to each other but also **operate on shared logic**. It transforms communication into **structured computation**.

The A2A Protocol Queue: Unified Local and Remote Collaboration
--------------------------------------------------------------

To mediate both local interactions and remote collaborations, GI introduces the A2A Protocol Queue.

*   Internally, it routes state transition intents between co-located agents in the shared state graph
    
*   Externally, it serializes A2A-compliant messages and dispatches them to remote agents
    
*   Symmetrically, it reconciles remote responses back into local state transitions
    

The A2A Protocol Queue acts as the single coordination bus, enabling seamless continuity between in-memory FSM logic and cross-network protocol execution. Whether a task involves a local actor or a remote LLM agent, the coordination flow is structurally identical.

Why Rust?
---------

Rust is not just a high-performance systems language—it is a compiler-enforced framework for correctness and safety. For agent infrastructure, it provides:

*   **Zero-cost abstractions**: expressive agent logic without runtime penalty
    
*   **Safe concurrency**: multi-agent coordination with thread-safe guarantees
    
*   **Async orchestration**: embedded scheduling and tool chaining with native `async` / `await`
    
*   **Compile-time validation**: state transitions are validated before execution
    
*   **Deterministic performance**: suitable for critical workflows and traceable behavior
    

Rust enables GI to treat agent orchestration as a **first-class systems problem**, not a duct-taped abstraction layer.

Infrastructure Overview
-----------------------

![](https://storage.googleapis.com/papyrus_images/48486655e011bf53a0f639992d33418b.png)

GI as an Executable Agent Substrate
-----------------------------------

Rather than layering protocol support on top of a generic platform, GI **embeds A2A and MCP directly into the execution logic**.

This turns protocol structure into **live, observable behavior**.

  

**Layer**

**Protocol**

**GI's Execution Role**

Tool Access

MCP

Native ToolUse engine supports MCP schemas as runtime calls

Agent Coordination

A2A

A2A semantics are compiled into the shared state graph

Orchestration

(Missing in most stacks)

Rust async engine powers state execution, lifecycle, and remote coordination

Conclusion: Protocols are the Schema, GI is the Machine
-------------------------------------------------------

The future of agent collaboration is not just about defining schemas. It is about compiling them into live, verifiable execution environments.

GI achieves this by:

*   Embedding A2A coordination into runtime logic
    
*   Managing local and remote agents as one unified swarm
    
*   Using Rust to enforce safety, composability, and concurrency
    
*   Capturing execution in transparent, on-chain state
    

**_Protocols define how agents talk. GI shows how they act._**

---

*Originally published on [General Impression](https://paragraph.com/@gi/beyond-a2a)*