EasyNet is a Capability Control Plane built on top of the Axon Agent Invocation Protocol.
It turns every agent ability into a first‑class, addressable, signed, auditable network object — anchored to a formal seven‑tuple invocation axiom (Axon), and shipped as the reference instantiation across runtime, addressing, identity, and language SDKs.
- What EasyNet is
- Why an invocation protocol is needed
- What is already built
- Architecture
- Quick start
- FAQ
- RFC index
- Timeline
- Roadmap
- License
EasyNet is a Capability Control Plane for AI agents.
It turns every agent ability — quote.order, image.caption, a three‑day monitor, a one‑shot tool call — into a first‑class network object with its own identity, schema, trust posture, scheduling contract, and signed receipt. It is the layer that lets a fleet of agents discover, address, invoke, and audit each other's capabilities under a single uniform model.
EasyNet is a system of named layers; each layer has a precise role:
| Layer | Role | Tagline |
|---|---|---|
| EasyNet | The system abstraction users and operators see | Capability Control Plane for AI Agents |
| Axon | The wire‑level mechanism EasyNet stands on | An Agent Invocation Protocol for Open‑World Agent Systems |
| URA | The naming layer for agents, abilities, invocations, receipts | Capability Addressing |
| Nucleus | The identity and trust core | Identity & Trust |
| EAL | The mission / workflow description language | Mission Description Layer |
| Receipt Chain | The cross‑hop audit substrate | Execution Provenance |
A short way to read it:
EasyNet is a Capability Control Plane built on top of the Axon Agent Invocation Protocol.
Axon — the protocol EasyNet stands on — is anchored to a seven‑tuple axiom:
Invocation ≜
⟨caller, callee, ability, subject, nonce, causal_context, args⟩
This is the smallest closed unit of the agent network. Every ability has a stable URI under URA. Every invocation produces a signed receipt. Every receipt closes a graph the verifier can replay — across SDKs, languages, and wire bindings — because Axon's semantics are defined independently of the wire.
Two theorems sit on top of this axiom:
- Profile Necessity. Any wire realisation of the axiom requires a profile — a binding between the seven‑tuple and on‑wire encoding. The profile is forced, not chosen.
- Axiom Invariance. The invocation semantics are invariant under the profile, provided the profile satisfies the constraints
Q1–Q5. An A2A hop and an MCP tool call inside the same logical invocation produce a receipt chain the verifier closes without knowing which hop used which binding.
A public summary of the axiom — the seven‑tuple definition, the five invariants Q1–Q5, and the two theorems — is published at docs/concepts/AXIOM-summary.md. The full paper with proofs is in preparation for arXiv.
In today's AI agent stack, "agent A calls agent B's ability" is a function call wrapped in an RPC wrapped in a tool wrapped in a workflow. There is no shared object across those layers that says this is the invocation, this is what was called, this is what was returned, this is who signed for it.
The consequences are concrete:
- Capability is implicit. A gRPC method is a path, a request type, and a response type. It does not know its own visibility, scheduling contract, or receipt shape. Two services exposing the "same" method have no way to agree they are exposing the same ability.
- Provenance does not compose. A workflow that touches MCP tools, A2A skills, and internal RPCs produces traces in three formats with three id schemes. No verifier can close the chain.
- Identity is per‑layer. The agent's identity at the LLM layer, the orchestrator layer, and the network layer are three separate identities. Cross‑layer audit requires reconciliation, not verification.
- Policy races placement. Authorisation evaluates against one snapshot; the router places against another; the rate limiter counts against a third. Each is individually correct and collectively unsound.
These are not framework problems. They are the absence of a first‑class invocation object at the protocol layer — the gap the Axon protocol exists to close.
Once Axon makes the invocation first‑class, EasyNet — the capability control plane sitting on top — gets the following for free:
- Ability is a named, versioned, schema‑bearing object addressable by URI.
- Receipt is a single closed type — not three parallel types for missions, tools, and tasks.
- Capability admission — policy, placement, rate, isolation — commits atomically against one snapshot, because there is now one object to commit against.
- Federation is the same invocation traversing more than one administrative domain, not a separate concept.
This is the move the rest of EasyNet exists to make available.
EasyNet ships as a set of public artifacts. The reference runtime stabilises in private; everything users touch is on public registries.
| Spec | Scope | Status |
|---|---|---|
| URA | Unified Resource Addressing — the canonical URI scheme for agents, abilities, invocations, receipts | Public, draft |
| AXON‑RFC‑001 | Envelope + receipt alignment to the invocation axiom (single‑profile A2A construction) | Public draft · 150 / 150 RPCs classified |
| AXIOM summary | The seven‑tuple axiom, Q1–Q5 invariants, Profile Necessity, Axiom Invariance | Public summary · full paper in preparation |
| Component | What it is | Visibility |
|---|---|---|
| EasyNet‑Axon | Reference runtime — Rust control plane, profile‑bound canonical signing, atomic admission, federation hub, native Dendrite bridge | 🔒 Code private during stabilisation |
| EasyNet‑Nucleus | Identity core — agent genesis, lineage, capability registry | 🌐 Public |
| EAL | EasyNet Ability Language — compiles to a DAG of invocations (Mission IR) | Bundled with the CLI |
| Language | Package | Registry |
|---|---|---|
| Python | easynet-run-axon |
PyPI |
| Node.js | @easynet-run/node |
npm |
| React | @easynet-run/react |
npm |
| Go | easynet.run/axon/sdk/go |
Go module proxy · mirror at easynet‑axon‑go |
| Java | run.easynet:axon-sdk |
Maven Central (release train) |
| Swift | EasyNet‑Axon SPM package | GitHub Release artifact (universal binary) |
| Rust | easynet-axon |
workspace crate |
All language SDKs share the same canonical wire — they consume the same native Dendrite bridge (C ABI, all gRPC streaming shapes). Receipts produced by any SDK verify under any other.
┌──────────────────────────────────────────────────────────────────────┐
│ │
│ Language surfaces │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Python · Node · React · Go · Java · Swift · Rust │ │
│ │ pip · npm · go.dev · Maven · SPM │ │
│ └─────────────────────────┬────────────────────────────────┘ │
│ │ │
│ Mission layer (compile‑time) │
│ ┌─────────────────────────▼────────────────────────────────┐ │
│ │ EAL — EasyNet Ability Language │ │
│ │ · Mission IR (DAG of invocations) │ │
│ │ · Compiler · Dispatcher · CLI │ │
│ └─────────────────────────┬────────────────────────────────┘ │
│ │ │
│ Invocation semantics │
│ ┌─────────────────────────▼────────────────────────────────┐ │
│ │ Axon — reference runtime │ │
│ │ · Atomic invocation admission │ │
│ │ · Profile‑bound canonical signing & receipts │ │
│ │ · Federation hub (NAT‑traversing outbound gRPC) │ │
│ │ · Dendrite bridge (C ABI, all gRPC shapes) │ │
│ └─────────────────────────┬────────────────────────────────┘ │
│ │ │
│ Identity & addressing │
│ ┌──────────────┬──────────▼───────────────┐ │
│ │ URA │ Nucleus │ │
│ │ Unified │ Agent identity, │ │
│ │ Resource │ genesis, lineage, │ │
│ │ Addressing │ capability registry │ │
│ └──────────────┴──────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────┘
pip install easynet-run-axon # Python
npm install @easynet-run/node # Node.js
npm install @easynet-run/react # React
go get easynet.run/axon/sdk/go # Gofrom easynet_axon import ability, serve
@ability("easynet:///r/org/reg/agent.quote-bot/abilities/order.quote@1?tenant_id=tenant-test")
def quote(ctx, sku: str, qty: int = 1):
return {"sku": sku, "price": 19.9 * qty}
serve("agent.quote-bot")from easynet_axon import client
res = (
client()
.tenant("tenant-test")
.ability("easynet:///r/org/reg/agent.quote-bot/abilities/order.quote@1?tenant_id=tenant-test")
.call({"sku": "A1", "qty": 2})
)from easynet_axon import start_server
srv = start_server(
hub="axon://hub.easynet.run:50084",
hub_tenant="tenant-test",
hub_label="alice-macbook",
)The SDK spawns a local runtime that joins a federation hub via outbound gRPC. No port forwarding, no public IP, no central broker for the data path.
What is EasyNet? EasyNet is a Capability Control Plane for AI agents. It turns every agent ability into a first‑class network object — with its own identity, schema, trust posture, scheduling contract, and signed receipt — and ships the reference instantiation across runtime (Axon), addressing (URA), identity (Nucleus), mission language (EAL), and seven language SDKs.
How is EasyNet related to Axon? EasyNet is the system abstraction (Capability Control Plane); Axon is the underlying Agent Invocation Protocol that makes the abstraction work. The relationship in one sentence: EasyNet is a Capability Control Plane built on top of the Axon Agent Invocation Protocol. Axon defines the seven‑tuple invocation axiom and the canonical encoding; EasyNet uses Axon to deliver the user‑facing control plane.
What is the Axon Agent Invocation Protocol?
Axon is a wire‑level protocol that specifies what an invocation is when one autonomous agent calls another's ability. It is anchored to a seven‑tuple ⟨caller, callee, ability, subject, nonce, causal_context, args⟩ and proven against five structural invariants Q1–Q5 (caller‑identity first‑class, callee‑identity invariant under key rotation, cross‑deployment non‑repudiable audit, invocation identity invariant across processes and time, subject‑addressability independent of executor). The full construction is in the AXIOM summary.
How does EasyNet compare to A2A and MCP? A2A (agent‑to‑agent) and MCP (Model Context Protocol) are wire bindings — they specify how messages are carried between agents and between agents and tools. Axon, the protocol EasyNet stands on, sits one level above: it specifies what the message means (which caller, which callee, which ability, what subject, what arguments, what receipt). Axon's RFC track formalises A2A as one profile of the invocation axiom (RFC‑003) and MCP as another (RFC‑004), so a receipt chain that crosses an A2A hop and an MCP tool call is closed by the same verifier.
What language SDKs does EasyNet support?
Python (easynet-run-axon on PyPI), Node.js (@easynet-run/node on npm), React (@easynet-run/react on npm), Go (easynet.run/axon/sdk/go via the Go module proxy), Java (Maven Central), Swift (SPM), and Rust. All SDKs are language surfaces over the Axon protocol — receipts produced by any SDK verify under any other.
When was EasyNet started?
The EasyRemote / EasyNet idea was conceived in November 2024 and first publicly announced on LinkedIn on 2024‑12‑11. The Axon reference runtime began on 2026‑02‑18, the addressing spec (URA) and identity core (Nucleus) went public on 2026‑02‑22 and 2026‑02‑20 respectively, and the first multi‑language SDK release shipped on 2026‑03‑19. Every public milestone is independently verifiable via GitHub createdAt, PyPI/npm upload timestamps, the LinkedIn post timestamp, or the Go checksum database.
Who maintains EasyNet? EasyNet is built by Silan Hu and contributors under the EasyRemote organization.
Is EasyNet open source? The specifications (URA, RFC drafts, AXIOM paper) and language SDKs are public under permissive licenses (Apache 2.0 for code, CC‑BY 4.0 for documents). The Axon reference runtime is private during stabilisation; SDKs that wrap it are public on PyPI, npm, the Go module proxy, Maven Central, and SPM.
What is URA?
URA — Unified Resource Addressing — is EasyNet's canonical URI scheme for naming agents, abilities, invocations, and receipts. An ability URI looks like easynet:///r/<scope>/<registry>/<agent>/abilities/<ability>@<version>?tenant_id=<tenant>. URA is published as a separate spec at github.com/EasyRemote/URA.
What is EAL? EAL — EasyNet Ability Language — is a small DSL that compiles to a DAG of invocations (Mission IR). Each IR node becomes a runtime Invocation; "Mission state" is the aggregate state of expanded Invocations, not a separate state machine. EAL is bundled with the CLI.
Can I run an agent behind NAT without a public IP? Yes. The SDK spawns a local Axon runtime that joins a federation hub via outbound gRPC. No port forwarding, no public IP, and no central broker is in the data path — the hub only mediates discovery and reverse‑connect.
| RFC | Title | Status |
|---|---|---|
| AXON‑RFC‑001 | Envelope + receipt alignment to the invocation axiom (single‑profile A2A construction) | Draft · 150/150 RPCs classified |
| AXON‑RFC‑002 | Default profile: SystemAgent URIs, canonical args encoding, @latest resolution |
Planned |
| AXON‑RFC‑003 | Full A2A profile specification | In progress |
| AXON‑RFC‑004 | MCP profile — first multi‑profile realisation of the invocation semantics | Stub |
| AXON‑RFC‑005+ | Generic gRPC / custom profiles | Deferred |
Public RFC drafts will appear in this repository under docs/rfc/ as they ratify.
| Date | Milestone | Evidence |
|---|---|---|
| 2024‑11 | EasyRemote / EasyNet idea inception | — |
| 2024‑12‑05 | EasyRemote repository created |
GitHub createdAt |
| 2024‑12‑09 | easyremote first published to PyPI (v0.1.0.2.3) |
PyPI upload timestamp |
| 2024‑12‑11 | EasyRemote / EasyNet first publicly announced | LinkedIn post |
| 2025‑05‑28 | EasyRemote GitHub organization founded |
Org page created_at |
| 2026‑02‑18 | EasyNet‑Axon initial commit |
GitHub server timestamp |
| 2026‑02‑20 | EasyNet‑Nucleus public — identity core |
GitHub createdAt |
| 2026‑02‑22 | URA public — Unified Resource Addressing Spec |
GitHub createdAt |
| 2026‑03‑19 | First multi‑language SDK release on PyPI + npm + Go module proxy | PyPI · npm · go.dev — third‑party immutable upload timestamps |
| 2026‑04‑03 | EasyNet‑Cli initial commit — EAL compiler, Mission IR, ability dispatch |
GitHub server timestamp |
| 2026‑04‑19 | Concept Model frozen — Agent + Invocation as the two runtime first‑class citizens | Internal consensus |
| 2026‑04‑26 | AXON‑RFC‑001 — 150/150 RPCs restated under the invocation axiom | RFC document |
| 2026‑05‑29 | Public umbrella launch — this repository | You are here |
Every "public" milestone is independently verifiable: GitHub repository createdAt, PyPI/npm upload timestamps, and the Go checksum database are all third‑party immutable records.
Publish RFC‑001 in this repository underDone —docs/rfc/.docs/rfc/AXON-RFC-001.md.Publish a public summary of AXIOM.Done —docs/concepts/AXIOM-summary.md.- Publish the full AXIOM companion paper on arXiv.
- Ratify RFC‑003 (full A2A profile) and RFC‑004 (MCP profile), producing the first multi‑profile receipt chain demo.
- Open the Axon reference runtime when the public profile surface has stabilised.
- Code (when published): Apache License 2.0
- Documents, RFCs, and specifications: Creative Commons Attribution 4.0 (CC‑BY 4.0)
The URA spec, the seven‑tuple invocation axiom, and the RFC documents may be used in derivative work with attribution.
Built by Silan Hu · easynet.run · github.com/EasyRemote