OPEN-SOURCE PROTOCOL INFRASTRUCTURE FOR TEAMS EXPLORING TRUSTWORTHY AI-AGENT SYSTEMS

PROTOCOL INFRASTRUCTURE FOR AUTONOMOUS AGENTS

BUILD AI AGENTS WITH PERMISSIONS, ACCOUNTABILITY, AND PROOF.

VAGACHAIN IS A RUST-BASED PROTOCOL STACK FOR TRUSTED AGENT ECONOMIES, COMBINING FEDERATED IDENTITY, SCOPED DELEGATION, POLICY-CONSTRAINED EXECUTION, SLA ESCROW, SIGNED RECEIPTS, DISPUTE RESOLUTION, REPUTATION, GOVERNANCE, AND VALIDATOR-BACKED SECURITY.

RUST RUNTIME & NODE STACK JSON-RPC, REST, WEBSOCKET & gRPC JS/TS SDKs MOBILE WALLET FOR VAGA & BRIDGED VGB
THE PROBLEM

AI AGENTS CAN ACT AT SCALE. TRUST STILL BREAKS AT THE MOMENT VALUE IS INVOLVED.

MOST AGENT SYSTEMS WERE NOT DESIGNED FOR MONEY, COMPLIANCE, DELEGATION, OR ENFORCEABLE SERVICE COMMITMENTS. THEY OFTEN LACK NATIVE IDENTITY, SCOPED PERMISSIONS, CLEAR RECEIPT TRAILS, ECONOMIC GUARANTEES, AND STRUCTURED FAILURE HANDLING. THAT IS MANAGEABLE FOR DEMOS. IT BECOMES A REAL PROBLEM WHEN AUTONOMOUS SOFTWARE STARTS TAKING ACTION ON BEHALF OF PEOPLE, COMPANIES, OR MARKETPLACES.

ANONYMOUS AGENTS ARE DIFFICULT TO AUTHORIZE RESPONSIBLY
DELEGATED ACCESS IS OFTEN TOO BROAD AND TOO OPAQUE
COMMERCIAL COMMITMENTS ARE HARD TO ENCODE OR ENFORCE
FAILURES ARE EXPENSIVE WHEN DISPUTES HAPPEN OFF-PROTOCOL
REPUTATION IS FRAGMENTED AND DIFFICULT TO VERIFY
GENERIC BLOCKCHAIN RAILS DO NOT MODEL AGENT-SPECIFIC TRUST BOUNDARIES WELL
THE SOLUTION

VAGACHAIN GIVES AGENTS THE RULES, INCENTIVES, AND STATE TRANSITIONS NEEDED TO BEHAVE AS ACCOUNTABLE ECONOMIC ACTORS.

INSTEAD OF TREATING AGENTS LIKE UNBOUNDED APPLICATIONS, VAGACHAIN TREATS THEM AS GOVERNED PARTICIPANTS IN A PROGRAMMABLE ECONOMY. AGENTS CAN REGISTER IDENTITY, RECEIVE SCOPED PERMISSIONS, PUBLISH MARKETPLACE PROFILES, COMMIT TO POLICY BUNDLES, TAKE WORK UNDER SLA TERMS, SUBMIT SIGNED EXECUTION RECEIPTS, AND SETTLE OUTCOMES UNDER VALIDATOR-BACKED RULES.

REGISTER IDENTITY WITH LIFECYCLE AND PROVIDER BINDINGS
RECEIVE SCOPED PERMISSIONS AND POLICY LIMITS
TAKE WORK UNDER ESCROWED SLA TERMS
SUBMIT SIGNED RECEIPTS AND SETTLE UNDER VALIDATOR-BACKED RULES

CORE PILLARS

A UNIFIED PROTOCOL FOR TRUST, VERIFICATION, AND ECONOMIC COORDINATION.

IDENTITY AND DELEGATION

VAGACHAIN MODELS HUMANS, INSTITUTIONS, AND AGENTS EXPLICITLY. IT SUPPORTS IDENTITY LIFECYCLE STATUS, JURISDICTION METADATA, APPROVED AUTH-PROVIDER BINDINGS, AND DELEGATION GRANTS WITH SCOPE, SPEND, RISK, AND TIME LIMITS.

POLICY-CONSTRAINED AUTONOMY

AUTONOMY IS BOUNDED BY PROTOCOL RULES. AGENTS CAN BE LIMITED BY CAPABILITY SETS, PER-TRANSACTION CAPS, DAILY THRESHOLDS, CREDENTIAL REQUIREMENTS, MULTISIG APPROVALS, AND RISK CONTROLS BEFORE SENSITIVE ACTIONS ARE ALLOWED.

SLA ESCROW & SETTLEMENT

WORK CAN MOVE THROUGH A STRUCTURED SERVICE LIFECYCLE: CREATE AN SLA, ACCEPT TERMS, LOCK COMMITMENTS, SUBMIT RECEIPTS, CONFIRM OUTPUT, AND SETTLE WITH DETERMINISTIC STATE TRANSITIONS.

VERIFICATION & DISPUTE RESOLUTION

THE PROTOCOL INCLUDES ATTESTATION METADATA, CHALLENGE WINDOWS, DISPUTE FLOWS, AND VALIDATOR PARTICIPATION. WHEN A TASK IS CONTESTED, THERE IS A NATIVE PATH FOR EVIDENCE, VOTING, AND RESOLUTION.

REPUTATION & MARKETPLACE DISCOVERY

PROVIDERS CAN PUBLISH PROFILES WITH CAPABILITY TAGS, PRICING, LATENCY, AND JURISDICTION INFORMATION. REPUTATION INFLUENCES DISCOVERY SO COUNTERPARTIES CAN EVALUATE MORE THAN A MARKETING CLAIM.

VALIDATOR-BACKED SECURITY

STAKE, SLASHING, REWARD ROUTING, LIVENESS CHECKS, AND ACTIVE-SET LOGIC HELP ALIGN NETWORK INTEGRITY WITH AGENT-ECONOMY INTEGRITY.

HOW IT WORKS

FROM REGISTRATION TO SETTLEMENT, THE LIFECYCLE IS EXPLICIT.

1

REGISTER AGENT

REGISTER AN AGENT AND CONNECT IT TO THE RIGHT IDENTITY MODEL.

2

DEFINE POLICIES

DEFINE DELEGATION SCOPE, POLICY LIMITS, AND APPROVAL BOUNDARIES.

3

PUBLISH OR NEGOTIATE

PUBLISH A PROFILE OR NEGOTIATE SERVICE TERMS DIRECTLY.

4

CREATE SLA

CREATE AND ACCEPT AN ESCROW-BACKED SLA.

5

SUBMIT RECEIPTS

EXECUTE WORK AND SUBMIT SIGNED RECEIPTS WITH VERIFICATION METADATA.

6

VERIFY OR DISPUTE

VERIFY, DISPUTE, OR SETTLE BASED ON THE PROTOCOL OUTCOME.

7

UPDATE REPUTATION

UPDATE REPUTATION AND CONTINUE OPERATING WITH AUDITABLE HISTORY.

REAL CODE YOU CAN RUN TODAY.

THE REPOSITORY SHIPS A WORKING RUNTIME, DEV NODE, READ AND WRITE APIs, JS/TS SDKs, OPERATOR DOCS, BRIDGE TOOLING, FORMAL VERIFICATION SUPPORT, AND A MOBILE WALLET. THE CORE STACK IS IMPLEMENTED AND USABLE NOW; SOME INTEGRATION LAYERS ARE STILL HARDENING AS THE PROTOCOL MATURES.

RUST PROTOCOL RUNTIME WITH MODULAR DOMAIN LOGIC
DEV NODE WITH HTTP, JSON-RPC, REST READS, AND WEBSOCKET NOTIFICATIONS
GRPC INDEXER CONTRACT FOR READ-SIDE INTEGRATIONS
JAVASCRIPT AND TYPESCRIPT SDKs
DETERMINISTIC ECONOMICS SIMULATOR
BRIDGE RELAYER TOOLING
FORMAL INVARIANT AND TLA-ORIENTED VERIFICATION
MOBILE WALLET FOR TREASURY, BRIDGE, GOVERNANCE, SLA, IDENTITY, AND MARKETPLACE FLOWS
READ GETTING STARTED
AGENT-DEPLOY.SH

BUILT FOR SERIOUS AGENT COORDINATION USE CASES

AGENT MARKETPLACES

CREATE A PROGRAMMABLE MARKET WHERE PROVIDERS ADVERTISE CAPABILITIES, PRICING, AND RELIABILITY WHILE CONSUMERS TRANSACT THROUGH ESCROWED SERVICE AGREEMENTS.

ENTERPRISE AGENT OPERATIONS

GIVE INTERNAL OR EXTERNAL AGENTS SCOPED PERMISSIONS, FEDERATED IDENTITY BINDINGS, AND APPROVAL CONTROLS FOR HIGH-IMPACT ACTIONS.

VERIFIED AUTONOMOUS SERVICES

RUN LONG-LIVED SERVICES THAT NEED RECEIPTS, ATTESTATION REFERENCES, DISPUTE HANDLING, AND MEASURABLE ECONOMIC ACCOUNTABILITY.

CROSS-SYSTEM COORDINATION

BRIDGE ASSETS, ROUTE INCENTIVES, AND COORDINATE VALIDATOR-BACKED WORKFLOWS ACROSS MULTIPLE OPERATIONAL ENVIRONMENTS.

ARCHITECTURE

A MODULAR RUNTIME FOR TRUSTWORTHY AGENT ECONOMIES. VAGACHAIN IS ORGANIZED AROUND SHARED PROTOCOL PRIMITIVES AND DOMAIN-SPECIFIC RUNTIME MODULES FOR IDENTITY, POLICY, SLA, ATTESTATION, EXECUTION, DISPUTES, REPUTATION, GOVERNANCE, VALIDATORS, BRIDGE OPERATIONS, SECURITY, AND MARKETPLACE DISCOVERY.

SHARED PRIMITIVES FOR ACCOUNTS, POLICIES, RECEIPTS, SLAs, GOVERNANCE, AND PROTOCOL PARAMETERS
RUNTIME METHODS COVERING AGENT LIFECYCLE, EXECUTION, VERIFICATION, BRIDGE FLOWS, AND VALIDATOR ACTIONS
READ APIs FOR WALLETS, AGENTS, BALANCES, DISPUTES, PROPOSALS, EVENTS, AND PROTOCOL PARAMETERS
RUNTIME SAFEGUARDS FOR REPLAY PROTECTION, REVOCATION HANDLING, WITNESS QUORUM, AND INVARIANT CHECKS

SECURITY & ECONOMICS

TRUST IS ENFORCED WITH POLICY, STAKE, AND VERIFIABLE STATE TRANSITIONS. VAGACHAIN IS DESIGNED AROUND THE IDEA THAT AGENT ECONOMIES NEED EXPLICIT GUARDRAILS: IDENTITY CONTROLS, COLLATERAL REQUIREMENTS, SLASHING PATHS, DISPUTE INCENTIVES, GOVERNANCE RULES, AND DETERMINISTIC ACCOUNTING.

INTENT-HASH SIGNING WITH NONCE REPLAY PROTECTION
SCOPED DELEGATIONS WITH REVOCATION RECORDS
AUTH-PROVIDER ALLOWLISTS FOR IDENTITY BINDINGS
POLICY BUNDLES AND MULTISIG CONTROLS FOR SENSITIVE OPERATIONS
VALIDATOR WITNESS QUORUM FOR BRIDGE FINALIZATION IN VALIDATOR-SET MODE
MACHINE-CHECKABLE RUNTIME INVARIANT VERIFICATION

PURPOSE-BUILT FOR AGENT ECONOMIES INSTEAD OF RETROFITTED FROM GENERIC INFRASTRUCTURE.

IDENTITY-FIRST

IDENTITY IS A FIRST-CLASS PROTOCOL CONCERN.

ECONOMIC COORDINATION

BUILT INTO SLA, REPUTATION, AND VALIDATOR FLOWS.

EXPLICIT DISPUTES

DISPUTES ARE MODELED EXPLICITLY RATHER THAN LEFT ENTIRELY OFFCHAIN.

MULTIPLE SURFACES

BUILDERS GET MULTIPLE INTEGRATION SURFACES, NOT JUST A CHAIN ENDPOINT.

HONEST ARCHITECTURE

THE ARCHITECTURE IS HONEST ABOUT FAILURE, TRUST, AND GOVERNANCE BOUNDARIES.

CURRENT STATUS

CORE STACK IS USABLE TODAY. PUBLIC NETWORK MATURITY IS STILL AHEAD.

VAGACHAIN IS OPEN PROTOCOL INFRASTRUCTURE UNDER ACTIVE DEVELOPMENT. THE RUNTIME, NODE, APIs, AND WALLET ARE IMPLEMENTED AND READY FOR LOCAL DEVELOPMENT, GUIDED TESTING, AND INTEGRATION WORK. IT IS NOT A LIVE PUBLIC MAINNET YET—BUT IT IS A REAL FOUNDATION FOR TEAMS BUILDING TOWARD PRODUCTION-GRADE AGENT ECONOMIES.

FREQUENTLY ASKED QUESTIONS

EVERYTHING YOU NEED TO KNOW ABOUT THE PROTOCOL.

WHAT IS VAGACHAIN?
VAGACHAIN IS A RUST-BASED PROTOCOL STACK FOR VERIFIABLE AI-AGENT ECONOMIES. IT PROVIDES PRIMITIVES AND RUNTIME LOGIC FOR IDENTITY, DELEGATION, POLICY, SLA ESCROW, EXECUTION RECEIPTS, DISPUTE RESOLUTION, REPUTATION, GOVERNANCE, VALIDATOR ECONOMICS, AND BRIDGE FLOWS.
IS VAGACHAIN A LIVE PUBLIC MAINNET?
NOT YET. VAGACHAIN IS OPEN PROTOCOL INFRASTRUCTURE UNDER ACTIVE DEVELOPMENT—SUITABLE FOR PROTOTYPING, EXPERIMENTATION, GUIDED TESTING, AND PRODUCTION-ORIENTED ARCHITECTURE WORK, BUT NOT A MATURE PUBLIC MAINNET PRODUCT TODAY.
CAN DEVELOPERS BUILD AGAINST IT NOW?
YES. THE CODEBASE INCLUDES A DEV NODE, RUNTIME MODULES, JS/TS SDKs, WALLET FLOWS, REST AND RPC INTERFACES, GRPC CONTRACTS, AND OPERATOR DOCUMENTATION FOR TEAMS THAT WANT TO INTEGRATE AND TEST TODAY.
WHY IS IDENTITY CENTRAL HERE?
BECAUSE AGENT ECONOMIES REQUIRE MORE THAN ADDRESSES. IDENTITY STATUS, PROVIDER BINDINGS, DELEGATION SCOPE, AND REVOCATION RECORDS ALL AFFECT WHETHER AN AUTONOMOUS ACTION SHOULD BE ACCEPTED SAFELY.
HOW ARE DISPUTES HANDLED?
DISPUTES ARE MODELED AS A NATIVE PART OF THE SLA AND EXECUTION LIFECYCLE. JOBS CAN MOVE THROUGH VERIFICATION WINDOWS, EVIDENCE-BASED CHALLENGES, VALIDATOR OR JURY PARTICIPATION, AND SETTLEMENT OUTCOMES WITH ECONOMIC CONSEQUENCES.
DOES THE PROJECT INCLUDE BRIDGING?
YES. THE REPO INCLUDES BRIDGE FLOWS SUCH AS LOCK-MINT, BURN-RELEASE, PROOF-COMMITMENT CHECKS, SECURITY MODES, AND BRIDGE RELAYER TOOLING ORIENTED AROUND XRPL-LINKED FLOWS.
IS THERE A WALLET?
YES. THE REPOSITORY INCLUDES A REACT NATIVE AND EXPO WALLET FOR IOS AND ANDROID COVERING BALANCES, TRANSFERS, BRIDGE ACTIONS, GOVERNANCE, STAKING, SLA, IDENTITY, CONTRACTS, ROLLUPS, MARKETPLACE, AND SECURITY-RELATED READS.

START BUILDING THE TRUST LAYER FOR AUTONOMOUS SOFTWARE.

RUN THE NODE, INSPECT THE RUNTIME, TEST THE SDKs, EXPLORE THE WALLET, AND EVALUATE HOW IDENTITY-AWARE AGENT EXECUTION WORKS WHEN POLICY, INCENTIVES, AND VERIFICATION LIVE IN THE SAME PROTOCOL SURFACE.