> For the complete documentation index, see [llms.txt](https://www.anandisheladiya.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.anandisheladiya.com/research/blockchain-context-protocol.md). # Blockchain Context Protocol Giving AI Agents a Native Interface to Blockchains **Version:** Draft v0.1\ **Status:** Research Proposal\ **Category:** AI × Blockchain Interoperability\ **Date:** 2026 *** ## Abstract Blockchains expose state and execution through transaction-centric interfaces such as JSON-RPC. These interfaces are optimized for deterministic execution but are poorly suited for autonomous AI agents that operate using goals, constraints, and reasoning workflows. The **Blockchain Context Protocol (BCP)** proposes a standardized interface layer that allows AI agents to interact with blockchain systems using structured context, declarative intents, verifiable execution plans, and policy-based constraints. BCP introduces an agent-native interaction model that sits above existing blockchain execution standards such as ERC-4337, ERC-6900, and emerging agent authorization proposals. Rather than replacing transaction infrastructure, BCP introduces a reasoning and coordination layer enabling safe, explainable, and programmable agent behavior. *** ## 1. Introduction ### 1.1 Motivation Autonomous agents are increasingly performing tasks involving blockchain systems, including: * DeFi portfolio management * Automated trading and arbitrage * DAO governance participation * Treasury operations * Cross-chain asset routing * On-chain service orchestration Current blockchain interfaces require agents to: * Construct raw transactions * Query fragmented state across RPC endpoints * Rely on centralized indexers * Implement proprietary safety and simulation logic This results in: * Poor interoperability * Increased security risk * Limited explainability * High implementation complexity #### Problem Statement Blockchains lack a standardized **machine-readable context layer** suitable for AI-driven decision systems. *** ### 1.2 Design Goals BCP aims to: 1. Provide structured blockchain state for agent reasoning 2. Enable declarative intent-based execution 3. Introduce verifiable policy enforcement 4. Support multi-step execution planning 5. Provide execution proofs and explainability 6. Remain compatible with existing blockchain standards *** ## 2. Background ### 2.1 JSON-RPC Limitations JSON-RPC provides low-level transaction and state access. It assumes: * Caller already knows execution steps * Caller performs off-chain reasoning * Execution success is binary RPC lacks: * Semantic context * Policy frameworks * Intent abstraction * Execution planning primitives *** ### 2.2 Emerging Agent Infrastructure Several standards address agent execution primitives: | Standard | Role | | ------------------- | ----------------------------- | | ERC-4337 | Account abstraction | | ERC-6900 | Modular smart accounts | | ERC-8004 (proposed) | Trustless agent authorization | | Intent Protocols | Goal-based execution routing | BCP complements these standards by providing a **coordination interface**. *** ## 3. System Overview BCP introduces four primary components: #### 1. Context Layer Provides normalized blockchain state. #### 2. Intent Layer Defines goal-oriented agent requests. #### 3. Policy Layer Defines constraints and safety boundaries. #### 4. Execution Layer Plans and executes verifiable actions. *** ## 4. Architecture ``` +------------------------------------------------------+ | AI AGENT | | Planning • Reasoning • Learning | +-----------------------▲------------------------------+ | | +------------------------------------------------------+ | Blockchain Context Protocol (BCP) | | | | Context Engine → State Normalization | | Intent Engine → Goal Translation | | Policy Engine → Constraint Verification | | Execution Planner → Action Strategy | +-----------------------▲------------------------------+ | | +------------------------------------------------------+ | Smart Account / Agent Authorization | | ERC-4337 • ERC-6900 • ERC-8004 | +-----------------------▲------------------------------+ | | +------------------------------------------------------+ | BLOCKCHAIN | +------------------------------------------------------+ ``` *** ## 5. BCP Core Concepts *** ### 5.1 Context Object BCP defines standardized state objects. #### Example ```json { "account": { "address": "0xAgent", "balances": [ {"asset": "USDC", "amount": "5000"}, {"asset": "ETH", "amount": "2"} ], "positions": [ {"protocol": "Aave", "collateral": "ETH", "health": 1.8} ] }, "network": { "chain": "ethereum", "gas": 45 } } ``` *** ### 5.2 Intent Object Intents describe desired outcomes instead of transactions. ```json { "goal": "Optimize yield", "constraints": { "max_risk": "medium", "max_slippage": "0.5%" } } ``` *** ### 5.3 Policy Object Policies define enforceable execution rules. ```json { "rules": [ {"max_trade_size": "20%"}, {"allowed_protocols": ["Aave", "Uniswap"]} ] } ``` *** ### 5.4 Execution Plan Execution plans define multi-step strategies. ```json { "steps": [ {"action": "withdraw", "protocol": "Aave"}, {"action": "swap", "protocol": "Uniswap"} ] } ``` *** ## 6. Protocol Specification *** ## 6.1 BCP V0 — Minimal Interface V0 introduces basic primitives for agent execution. *** ### 6.1.1 Endpoints #### Context Query ``` GET /bcp/context/{account} ``` Returns normalized blockchain state. *** #### Intent Submission ``` POST /bcp/intent ``` Accepts declarative goal objects. *** #### Policy Validation ``` POST /bcp/policy/validate ``` Verifies constraints. *** #### Execution ``` POST /bcp/execute ``` Triggers execution via smart accounts. *** ### 6.1.2 Execution Flow ``` Agent → Request Context Agent → Generate Intent BCP → Validate Policy BCP → Generate Execution Plan Smart Account → Execute BCP → Return Proof ``` *** ## 6.2 BCP V1 — Advanced Agent Coordination V1 introduces: #### Multi-chain Context Aggregation Unified cross-chain state views. #### Simulation Engines Pre-execution state forecasting. #### Route Optimization MEV-aware execution planning. #### Intent Market Integration Third-party solver coordination. #### Proof Framework Cryptographic execution attestations. *** ## 7. Security Model BCP relies on multiple security layers: #### Authorization Delegation through trustless agent standards. #### Policy Enforcement Pre-execution rule validation. #### Simulation Risk forecasting and rollback prevention. #### Verifiable Proofs Execution attestation and auditability. *** ## 8. Interoperability BCP is designed to integrate with existing Ethereum standards. *** ### 8.1 ERC-4337 BCP execution plans are translated into UserOperations. *** ### 8.2 ERC-6900 BCP policies can be implemented as modular account extensions. *** ### 8.3 ERC-8004 (Proposed) Defines agent delegation and authorization. *** ## 9. Real-World Use Cases *** ### 9.1 Autonomous DeFi Portfolio Agents Agents rebalance assets based on risk-adjusted yield metrics. *** ### 9.2 DAO Governance Agents Agents vote according to predefined treasury policies. *** ### 9.3 Cross-Chain Payment Routing Agents optimize transaction routes across L2s and bridges. *** ### 9.4 On-chain Service Automation Agents subscribe, renew, and manage decentralized services. *** ## 10. Implementation Considerations *** ### 10.1 Off-chain BCP Providers Initial implementations may run as decentralized indexing and execution networks. *** ### 10.2 On-chain Policy Modules Policy engines can be deployed as verifiable smart contracts. *** ### 10.3 Standardization Path BCP may evolve through: * Ethereum Improvement Proposals * Open agent interoperability consortiums * Integration with AI model orchestration standards *** ## 11. Limitations * Requires standardized indexing infrastructure * Introduces additional coordination latency * Policy standardization remains unsolved * Cross-chain trust models need formal verification *** ## 12. Future Research Directions * ZK-based context verification * Intent auction markets * Agent reputation scoring * Autonomous policy learning * Decentralized execution solvers *** ## 13. Conclusion Blockchain Context Protocol introduces an agent-native interface for blockchain coordination. By shifting interaction from transaction construction to intent execution, BCP enables safer, more interoperable, and programmable agent ecosystems. BCP is not a replacement for blockchain execution standards. Instead, it represents a coordination layer enabling AI systems to safely reason about and operate within decentralized environments. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://www.anandisheladiya.com/research/blockchain-context-protocol.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.