Capability-native network: the network's basic unit is no longer a host, service, or file, but an Ability that can be authorized, invoked, and verified.
Open capability runtime for AI agents: publish, invoke, audit, and orchestrate governed abilities across owners, devices, models, tools, and services.
EasyNet is not a VPN, an ISP, or a generic networking tool. It is the runtime layer that turns private capabilities into addressable, policy-governed, receipt-backed network objects.
The next software runtime is no longer made only of deterministic APIs, database operators, and scheduled jobs. Production workflows now call LLMs, agents, MCP tools, external SaaS services, private models, local devices, and human-in-the-loop systems. These capabilities are powerful, but they are scattered across owners, machines, accounts, networks, and trust boundaries.
Today, a capability usually lives behind one framework, one API key, one server, or one agent session. It has no stable network identity, no portable execution contract, no verifiable receipt, and no durable execution history that can be optimized over time.
EasyNet Runtime gives every capability a routable identity, a governed execution contract, and a receipt-backed invocation path.
A capability can stay where it belongs: on the owner's machine, inside the owner's model runtime, behind the owner's SaaS account, or attached to the owner's device. Other software can discover and invoke it through a complete, signed, auditable protocol call. The caller receives a result and a receipt, not the underlying model, code, credential, or data source.
A research workflow needs protein-folding inference but has no local GPU. A remote owner publishes a fold capability from their own GPU box. The workflow discovers the capability, invokes it through EasyNet, receives the result, and keeps a receipt for verification and audit. The model weights never leave the owner's machine.
In open-world agent execution, the missing layer is a capability runtime:
| Problem | EasyNet's answer |
|---|---|
| Capabilities are trapped inside one runtime, API, account, or framework | Ability gives each capability a stable network contract |
| Callers cannot safely invoke capabilities owned by others | Invocation carries caller, callee, ability, subject, nonce, causal context, and args as a signed object |
| Execution is hard to audit or replay safely | Receipt records the verifiable terminal fact of the call |
| Similar workflows repeatedly re-plan from scratch | Execution traces become reusable optimization material |
| Private models and devices sit behind NAT or local trust boundaries | The capability stays with its owner; EasyNet routes the call |
One line: EasyNet Runtime is the open capability runtime for AI agents: publish governed abilities, invoke them across ownership boundaries, and close every execution with a verifiable receipt.
If AI remains chat, EasyNet is unnecessary.
EasyNet exists for the moment AI becomes an actor across resources it does not own: private devices, private models, local context, SaaS accounts, enterprise networks, and human-controlled systems.
At that boundary, tool access is not enough. The system must know who called, which capability was invoked, what subject it acted on, which authority admitted it, what actually executed, and which receipt closes the action.
EasyNet turns that boundary into a runtime model: Ability, Invocation, Admission, and Receipt.
easynet is the operator CLI for EasyNet Runtime. It starts
easynet-daemon, joins an Axon Hub, publishes local capabilities as governed
Abilities, dispatches complete signed Invocations, and records execution facts
as receipts.
Four product surfaces, one installed Runtime:
-
Daemon runtime:
easynet runtime startlauncheseasynet-daemon, the product runtime that owns device lifecycle, local policy, plugins, ability registration, dispatch, and receipt projection. -
CLI:
easynet device ...,easynet ability ...,easynet plugin ..., andeasynet invocation ...expose the operator surface for devices, abilities, plugins, and audit records. -
EAL compiler: EAL (EasyNet Ability Language) is a DSL for distributed ability orchestration. Write a
.ealfile, and the compiler infers a dependency DAG from variable references, partitions it into parallel phases, and compiles it to Mission IR v2, a serializable execution plan. -
MCP server:
easynet mcp serveexposes the local runtime over stdio so a co-located AI development environment can call governed EasyNet abilities through the daemon.
These surfaces are not literally one binary. A complete install includes the
easynet CLI, easynet-daemon, easynet-keyring,
easynet-remoteapp-native-host, easynet-remoteapp-media-host (or its signed
macOS app), libeasynet_cli, and libaxon_dendrite_bridge. The helpers keep
key custody and killable native workloads outside the CLI process.
Why this matters: EasyNet does not treat a capability as a local tool hidden inside one agent session. It treats the capability as a runtime object: addressable by URA, invoked through Axon, governed by daemon policy, and closed by a receipt.
| Layer | Repository | Responsibility |
|---|---|---|
| Protocol | EasyNet-Axon | URA, Ability, Invocation, Receipt, stream/bidi, runtime semantics, SDK conformance |
| Runtime | EasyNet-Cli | EasyNet Runtime: easynet-daemon, device lifecycle, plugins, local execution, EAL/Mission, CLI, MCP |
| Product | EasyNet | Web platform, federation backend, operator console, dashboards, product workflows |
| Python facade | EasyRemote | Python decorators, schema derivation, Ability packaging, and resident provider host |
| Optimization | IntentDB (research direction) | Learn reusable hybrid execution plans from receipt-backed traces |
Current deployments use separate device and hub roles. Although the config
parser accepts both, transport startup currently rejects it because its
publication/session recovery owner is missing. See the
current daemon mode contract before choosing a
deployment role.
The current topology is deliberately Hub-centered: local abilities execute in the local Runtime, remote devices maintain outbound reverse sessions to their realm Hub, and cross-realm calls travel through governed Hub-to-Hub federation. Realtime transports such as Remote Desktop may use Hub-mediated signaling to establish a direct data plane with relay fallback.
The governing principle is stable across every stage: the Hub remains the trust, routing, presence, and session-control plane, but it does not need to carry every realtime or bulk data byte. Ability, Invocation, Admission, and Receipt semantics remain identical regardless of the selected transport.
| Priority | Outcome | Completion criteria |
|---|---|---|
| P0 — Hub HA and session recovery | Preserve the current topology while removing single-process session ownership as a realm-wide failure point. | Hub failover and reconnect/resume use explicit lease epochs, fence stale owners, recover in-flight lifecycle state, and preserve one terminal Receipt. |
| P1 — Traffic-class isolation | Isolate control frames, unary RPC, long-lived streams, and bulk data so one traffic class cannot starve another. | Each class has bounded queues, flow control, and resource budgets; bulk or stream saturation cannot incorrectly mark a healthy device offline or block session control. |
| P2 — Path observability | Make route behavior and cost measurable before introducing more transport choices. | Route-labelled telemetry covers latency, Hub egress, queue saturation, reconnect rate, direct/relay selection, and terminal failure reasons with actionable dashboards and alerts. |
| P3 — Selective P2P session data planes | Extend direct transport only to concrete realtime or bulk sessions such as remote desktop, voice, or file transfer. | Session setup remains an authorized Invocation; direct and relay paths form one explicit recovery state machine; endpoints remain transport metadata rather than identity; every run still closes with a verifiable Receipt. |
| P4 — Federation at scale | Evolve beyond manually maintained peer maps without turning observed endpoints into implicit route authority. | Signed route advertisements, trust-policy acceptance, expiry/revocation, health selection, and bounded failure recovery support large federations while keeping Hub-to-Hub routing governed. |
This roadmap does not turn EasyNet into a VPN or a generic peer-to-peer mesh. It evolves the transport beneath the governed capability runtime only where a measured use case requires it.
EasyNet's receipt-backed execution history makes a higher-level system possible: IntentDB, a database-style optimizer for open-world capability execution.
IntentDB treats user intent as a managed object, learns recurring execution patterns from historical traces, promotes stable patterns into deterministic operators, and keeps uncertain reasoning only where it is still necessary. This layer is a research direction, not a completed runtime feature in this repository.
Production release:
curl -sSf https://easynet.run/install | sudo shDeveloper checkout (with EasyNet-Axon beside this repository):
packaging/release/dev-install-local.sh --debugcargo install --path . is not the complete Runtime install: it omits the
native Axon bridge and the helper process set installed by the release scripts.
Note:
easynet runtime startlauncheseasynet-daemon, which embeds the Axon Invocation runtime and joins the Hub. Product/device paths should target the daemon, not a standalone Axon reference runtime.
easynet login
easynet device join <pairing-token>
easynet runtime start
easynet status
easynet device list
easynet ability listInvoke a local ability by canonical Ability URA. Public ingress requires the caller-controlled tuple fields; the CLI does not invent the subject, nonce, or causal placement:
easynet ability invoke <ability-ura> \
--subject <resource-ura> \
--nonce-hex <32-hex-chars> \
--causal-root \
--args '{"key":"value"}'Remote invocation uses the same tuple contract and additionally pins the target runtime owner:
easynet ability invoke <ability-ura> \
--node <device-ura> \
--subject <resource-ura> \
--nonce-hex <32-hex-chars> \
--causal-root \
--args '{"key":"value"}'Run an ad-hoc command through the ability surface:
easynet ability exec <node-id> -- uname -aCreate and install a local plugin package:
easynet plugin init ./hello-plugin --language python
easynet plugin install ./hello-plugin
easynet plugin status <package-id>Expose the local runtime to an MCP-capable client:
easynet mcp status
easynet mcp install codex --name easynet --tenant myteam
easynet mcp serve --tenant myteamEAL is a DSL for distributed ability orchestration. It separates what to execute from how to schedule it — you write the data flow, the compiler figures out the parallelism.
mission "daily-report" {
// Phase 0: independent — dispatched in parallel
let photo = call "photo.capture" on "edge-cam-01" with {
resolution = "4k"
} timeout 30
let config = call "config.fetch" on "coordinator"
// Phase 1: depends on photo + config — data-flow barrier
let result = call "model.inference" on "gpu-rig" with {
input = photo.output,
model_config = config.output
} timeout 120 retries 2 on_failure retry
// Phase 2: depends on result
let report = call "data.collect" on "home-server" with {
data = result.output,
template = "daily-report"
}
// Fire-and-forget (phase 0, no binding)
call "metrics.ping" on "monitor" optional
}
Compile or run an EAL mission:
easynet mission compile examples/diamond.eal --emit-ir
easynet mission run examples/daily-report.eal --traceThe command tree is generated by Clap and changes faster than this overview. Use the installed binary as the command source of truth:
easynet --help
easynet runtime --help
easynet ability --help
easynet mission --help
easynet mcp --helpApache-2.0 — see LICENSE.
This repository is a deliberately bounded public release of the wider EasyNet research system. See Public Source Release Scope for what is published, what remains outside the distribution, and why releases are staged.