AgentNet

• 

  placement

• 

  Contract

• 

  API docs

• 

  Control panel

Inspiration

As AI agents become more capable, the next challenge is getting agents built with different runtimes, models, and protocols to work together safely. A2A and MCP help agents communicate and use tools, but they do not answer basic governance questions: Who is allowed to act? Which agent should execute a task? What authority was granted? And can we prove what happened afterward?

We built AgentNet to address this missing layer.

What it does

AgentNet is a governance control plane for AI agent execution.

It connects the existing agent ecosystem without trying to replace it:

• AGNTCY provides agent discovery.
• AgentNet evaluates policy, selects an eligible agent, and issues authority.
• A2A handles agent-to-agent communication.
• MCP provides tool access.
• Agent runtimes execute the actual AI task.

The governed flow is:

Discover → Evaluate → Place → Authorize → Contract → Execute → Verify → Audit

AgentNet creates signed execution contracts before work begins and produces signed receipts afterward. It can also deny execution when a task violates policy or exceeds the agent's authority.

How we built it

We built AgentNet as a Python-first control plane using AGNTCY, FastAPI, PostgreSQL, Redis, NATS JetStream, Ed25519 signatures, A2A, MCP, and the OpenAI Agents SDK.

The core design is intentionally deterministic. AgentNet does not use an LLM to decide authorization, placement, leases, or policy. These decisions must be explainable and reproducible.

The Control Room makes the execution lineage visible, from the original task and policy decision to the selected agent, execution contract, tool activity, receipt, and audit trail.

Challenges we ran into

The biggest challenge was defining what AgentNet should not build.

The ecosystem already has protocols for communication, discovery, tool access, and agent execution. We had to find the missing infrastructure layer without duplicating those responsibilities.

We also had to solve practical distributed-systems problems: preventing stale workers from acting after reassignment, making contracts verifiable across runtimes, handling duplicate events safely, and preserving evidence without storing sensitive prompts or chain-of-thought.

Accomplishments we're proud of

We are proud that AgentNet is more than another multi-agent chat demo. It demonstrates a governed execution path:

Discovery → Policy → Placement → Signed Contract → A2A Execution → Agent Runtime → MCP Tool → Signed Receipt → Provenance → Audit

The most important idea is simple:

Agents should not only be able to act. We should be able to prove why they were allowed to act and what happened afterward.

What we learned

We learned that connecting agents is not the same as governing them.

Communication is not authorization. Discovery is not permission. A capability is not authority. And an agent claiming that it completed a task is not the same as having verifiable evidence of execution.

The project also taught us how important boundaries are in the emerging agent ecosystem. AgentNet works alongside existing standards instead of trying to replace them.

What's next

We want to evolve AgentNet into production-grade governance infrastructure for multi-agent systems.

Future work includes deeper identity and attestation, broader runtime integrations, stronger MCP enforcement, hardware-backed key management, policy simulation, multi-verifier approval, federation, and enterprise compliance controls.

Our long-term goal is to make autonomous AI systems more trustworthy by ensuring that agents can act independently—but never without accountability.

Built With

• a2a-protocol
• agntcy
• ai-governace
• architecture
• auditability
• authorization
• cryptography
• developer
• distributed
• docker
• docker-compose
• ed25519
• event-driven
• fastapi
• gpt-5.6
• mcp
• multi-agent-system
• openai-agents-sdk
• orchestration
• policy-based
• postgresql
• provenance
• pydantic
• python
• redis