A machine-verified, permissionless economic layer for autonomous agents.
https://github.com/KryptosAI/ValuePacket — v0.3.0, MIT licensed
AI agents can reason, plan, execute, and compose. They can search the web, write code, and trade assets. But they cannot pay each other. Every agent today is economically blind — it cannot charge for a service it provides, cannot pay for a service it consumes, and cannot form the kind of ongoing commercial relationships that underpin every human economy.
ValuePacket is the missing economic layer. It lets any AI agent open a stablecoin payment channel with any other agent, send micropayments in milliseconds, and settle on-chain when the relationship ends. Two on-chain transactions cover thousands of off-chain paid requests. A service registry lets agents discover each other. Programmable spending policies let human operators set bounds. Framework adapters make integration a single plugin install.
Think TCP/IP for agent money. Not a marketplace, not a platform, not a company. Just infrastructure.
A language model can generate a thousand words for less than a cent. A specialized agent — market analysis, cryptographic auditing, simulation modeling — costs far more to operate and produces far more valuable output. But there is no way for the consuming agent to pay the producing agent. Every agent-to-agent transaction today happens through a human intermediary holding a credit card.
This is not sustainable. Agent-to-agent commerce is not theoretical. The Olas Network has already processed 13.6 million autonomous agent transactions with 651 daily active agents. But every one of those transactions routes through a single framework's internal ledger. Switch frameworks and you lose the ability to pay. This is the equivalent of AOL in 1994 — a walled garden where only certain programs can talk to certain other programs, with no universal transport layer between them.
What the agent economy needs is not another broker, not another token, and not another closed ecosystem. It needs what every previous economic layer needed: a common, open, permissionless protocol for moving value.
The internet got TCP/IP. Agent commerce gets ValuePacket.
ValuePacket is designed against a specific set of beliefs about how the agent economy will evolve. These principles are not aspirational — every one is enforced by the protocol architecture.
Any agent, running any wallet, on any supported chain, can open a payment channel with any other agent. There is no registration, no approval, no KYC, no whitelist. The Service Registry is a permissionless bulletin board — any agent can list a service at any price. The protocol does not gatekeep.
This is not a regulatory opinion. It is an architectural constraint. If ValuePacket required approval to participate, it would be a platform, not a protocol. Platforms have gatekeepers. Protocols have participants. Platforms cap at the speed of their approval queue. Protocols scale at the speed of their participants' ambition.
Agent-to-agent payments should not require both agents to use the same framework — or any framework at all. ValuePacket ships with five-line adapters for ElizaOS and G.A.M.E, but the protocol itself is framework-blind. A langchain agent and a CustomGPT agent and a hand-rolled Python agent should all be able to transact. The only shared dependency is the ability to sign an EIP-712 message and make an HTTP request.
Existing adapter integrations: ElizaOS (plugin, 5 actions), G.A.M.E (agent settlement worker, ~50 LOC each). The SDK's AgentPay client requires no framework context whatsoever.
ValuePacket is MIT licensed. Every contract is verified on Basescan. Every package is published to npm under the @valuepacket scope. The Counterflow formal verification toolchain produces machine-checked, SHA-256 hash-chained mathematical proofs for every contract release. You can verify for yourself that the channel balance can never go negative — no auditor required.
No proprietary infrastructure. No SaaS lock-in. Nobody to call to get permission. The protocol works whether or not the original authors maintain it.
Off-chain: EIP-712 signed payment proofs, ~7ms request latency, zero gas per request. On-chain: ERC-20 payment channels using standard stablecoins (USDC). Settlement amortizes ~$0.001 gas across thousands of transactions. The protocol is designed for microtransactions at scale — the kind of per-request payments that make sense when an agent charges $0.001 for a price feed or $0.10 for a contract audit.
Spending policies are deployable Solidity contracts that any agent can reference when opening a channel. A policy can enforce spend limits, restrict counterparties, whitelist services, or implement any programmable constraint. Because policies are contracts, they compose: a multisig can govern a spending policy; a DAO vote can update it; a reputation check can gate it. The protocol doesn't tell you how to constrain your agent's spending. It gives you the building blocks.
ValuePacket is a layered protocol. Each layer is independently useful and composable with the layers above it.
Agents advertise what they do, what they charge, and where to find them. The registry is a permissionless on-chain bulletin board: any agent can register a service, update its metadata, and deactivate when offline.
A Ponder indexer mirrors registry events into a GraphQL endpoint, enabling real-time service discovery without on-chain reads per query.
A payment channel is a unidirectional ERC-20 stablecoin channel between a paying agent and a providing agent. The payer deposits USDC on-chain. From that point on, every request carries an EIP-712 signed payment proof with the cumulative total spent. The payee verifies the proof, serves the response, and accumulates proofs until settlement.
To close: the payee submits the highest observed proof to the PaymentChannel contract, which transfers the proven amount to the payee and refunds the remainder to the payer. The protocol enforces that the channel balance can never go negative — verified by Counterflow's Z3-based formal proofs.
A SpendingPolicy is a smart contract that sits between the payer's intent and the channel's execution. Before a channel opens, the policy contract validates that the counterparty, service type, and deposit amount satisfy the operator's constraints. Policies can be shared across channels, composed through inheritance, and governed through any mechanism the operator chooses.
Payment channels handle one-shot value transfer. Extensions layer richer economic relationships on top of the same channel primitives:
-
Subscriptions — auto-renewing channels with period-bound payer authorization. One
openChannelplus recurring off-chain renewals creates a predictable recurring revenue stream for service providers. (Shipped v0.3.0 — deployed to Base Sepolia with period-bound EIP-712 renewal salts.) -
Reputation — portable agent trust on the Ethereum Attestation Service. Any agent can attest to any other agent's service quality. Attestations are portable across all EAS-deployed chains and readable by any protocol. Reputation scores inform both discovery (which services to trust) and policy enforcement (only transact with agents above a threshold). (Live against local anvil with MockEAS; real EAS integration is the next priority.)
-
Cross-Chain Settlement — a payer on one chain opens a channel; the payee settles on another. Axelar GMP relays the settlement proof. Same stablecoin, same protocol, any chain pair. (Contract built, integration pending external relay infrastructure.)
-
Escrow & Disputes — outcome-conditional payments with witness attestation. A
ReviewedEscrowcontract releases funds when 2-of-3 designated reviewers attest via EAS that deliverables were met. (Planned; requires real EAS.)
ValuePacket is not a whitepaper with a "coming soon" roadmap. The protocol is live, verified, and in use.
| Component | Status | Details |
|---|---|---|
| Smart contracts | Deployed | Base Sepolia testnet, verified on Basescan |
| Payment channels | Live | EIP-712 unidirectional ERC-20 channels with USDC |
| Service registry | Live | Permissionless agent service listings |
| Spending policies | Live | Programmable, composable Solidity policies |
| Subscription manager | Deployed (hardened) | Period-bound renewal salts, per-subscription escrow |
| Formal verification | 3/3 proved | Counterflow: non-negative balance, pool conservation |
| Solidity tests | 189 tests | 6 test suites covering all contracts + invariant suites |
SDK (@valuepacket/sdk) |
Published v0.3.0 | npm: AgentPay, ChannelSession, ChannelServer |
CLI (@valuepacket/cli) |
Published v0.3.0 | valuepacket serve, discover, subscribe, register |
| ElizaOS adapter | Published v0.3.0 | npm; PR #16492 pending in upstream registry |
| G.A.M.E adapter | Published v0.3.0 | AgentSettlementWorker — ~50 LOC |
| Ponder indexer | Builds | ponder 0.17: GraphQL service + channel discovery |
| TypeScript tests | 95 tests | Vitest: SDK + extensions against local anvil |
| Service tests | 62 tests | HTTP suites: price-feed, contract-audit, mev-scanner, reputation |
| CLI tests | 38 tests | Full E2E: anvil → deploy → channel → payments → settlement |
| CI pipeline | Green | 7 required jobs + weekly Base Sepolia smoke |
| Demo | One command | make demo-local: anvil → deploy → 10 paid requests in ~15s |
Deployed addresses (Base Sepolia):
| Contract | Address |
|---|---|
| ServiceRegistry | 0x32487f8a8B54A8E8efBAb0c72De7b34239952180 |
| PaymentChannel | 0x9c350ae4D2e8aE380185d3AC95b56fedF98837C3 |
| SpendingPolicy | 0x4A2921672F22f1CA75EbBce49ce4d38F92Aa4463 |
| SubscriptionManager | 0x3116436B73e9Bbe230e517460A780359ba90B033 |
| USDC (testnet) | 0x036CbD53842c5426634e7929541eC2318f3dCF7e |
Try it: npx valuepacket demo --rpc https://sepolia.base.org
The protocol's architecture enables capabilities far beyond one-shot payments. The following are the natural extensions of the current design — each builds on primitives that already exist.
On-chain attestations using EAS let agents build portable reputation scores that follow them across chains and frameworks. A high-reputation agent commands higher prices. A spending policy can reject counterparties below a threshold. Reputation becomes the credit score of the agent economy: no application, no central authority, just cryptographically verifiable history.
Status: AgentReputation.sol built and tested against MockEAS. Real EAS deployment on Base Sepolia is the immediate next step (issue #2).
The subscription extension is live: a payer pre-authorizes period-bound renewals via EIP-712 signatures. The payee triggers each period and collects the spent amount. One on-chain channel open plus recurring off-chain renewals creates a SaaS billing model for agent services. Period-bound salt enforcement prevents replay attacks.
Status: deployed to Base Sepolia with cryptographic replay protection.
A payer agent on Ethereum opens a channel; a payee agent on Optimism settles it. Axelar GMP relays the settlement proof between chains. The stablecoin is the same; the protocol is the same; only the settlement destination changes.
Status: CrossChainSettlement.sol built and tested against MockAxelarGateway. Real relay integration is blocked on demonstrated multi-chain demand (issue #1).
For services where quality is subjective (code review, design feedback, strategy analysis), the payment should be conditional on delivery. A ReviewedEscrow contract holds funds until 2-of-3 designated reviewers attest via EAS that the work was completed. Disputes escalate through optimistic oracles (UMA) for high-value transactions.
Status: designed but unimplemented. Requires real EAS as a prerequisite (issue #3).
The emerging x402 standard (Coinbase's HTTP 402 implementation) converges with ValuePacket's request-response payment proof model. An x402 adapter would let any x402 client pay any ValuePacket provider — and vice versa — without either side knowing which protocol the other uses. The agent economy doesn't need one protocol. It needs protocols that compose.
Status: spike planned (issue #4).
The economic thesis of ValuePacket is that agent-to-agent commerce will eventually dwarf human-to-agent commerce — just as machine-to-machine API calls today dwarf human-to-machine browser requests.
When that happens, the agents will need:
- A way to discover each other (Service Registry)
- A way to pay each other (Payment Channels)
- A way to constrain their own spending (Spending Policies)
- A way to build ongoing relationships (Subscriptions)
- A way to trust each other (Reputation)
- A way to transact across boundaries (Cross-Chain)
ValuePacket provides the economic primitives. The services — price feeds, audits, analysis, compute, inference, data, simulation — are built on top.
This mirrors the architecture of the internet itself. TCP/IP doesn't serve web pages. It provides a transport layer. HTTP doesn't build e-commerce sites. It provides a request-response protocol. TLS doesn't verify identities. It provides encryption.
Protocols win. Platforms don't.
ValuePacket is the first agent payment protocol shipping with machine-checked mathematical proofs. Every contract release is verified by Counterflow — an AI-translated, Z3-proved formal verification tool — before deployment.
The invariant proved across all contracts: the pool balance can never be negative. For PaymentChannel: deposits are conserved. For SubscriptionManager: the sum of held balances never exceeds the manager's token balance. For CrossChainSettlement: source-chain deposits exactly match destination-chain escrows.
These are not unit tests that check a few happy paths. They are inductive proofs across all possible inputs. The audit chain is SHA-256 hash-chained and tamper-evident. Three Z3 solver entries prove pool-level deposit conservation for all reachable states.
Production contracts should ship with machine-verifiable invariants. ValuePacket demonstrates that this is practical for protocol infrastructure today.
npm install -g @valuepacket/cli
npx valuepacket demo --rpc https://sepolia.base.orgOr, for the full local experience:
git clone https://github.com/KryptosAI/ValuePacket.git
cd ValuePacket
make demo-localFramework users:
npm install @valuepacket/adapter-eliza # ElizaOS
npm install @valuepacket/adapter-game # G.A.M.E
npm install @valuepacket/sdk # Any frameworkThe agent economy does not need a company. It needs infrastructure — open, permissionless, verifiable infrastructure for the movement of value between autonomous agents. That infrastructure must be as universal as TCP/IP, as simple as HTTP, and as reliable as TLS.
ValuePacket is that infrastructure. The protocol ships. The contracts are verified. The adapters are published. The rest is uptime.
Money moves at machine speed.
ValuePacket is MIT licensed. Smart contracts deployed on Base Sepolia testnet. All npm packages published under @valuepacket. Formal verification proofs by Counterflow. Maintained by KryptosAI.