oMCP Research
oMCP Research: The On-Chain Model Context Protocol
Abstract
The on-chain Model Context Protocol (oMCP) is REVOX’s architecture for making model context—prompts, domain knowledge, on-/off-chain state, and tool interfaces—a first-class, verifiable resource for AI agents operating with smart contracts. Concretely, oMCP introduces contract/ABI registration, dynamic tool discovery, expanded Web3 data access (state, logs, storage, oracles), multi-language SDKs, and a roadmap toward cross-chain registries and one-click on-chain proxies. Combined with cryptographic or consensus verification (e.g., zkML, oracle attestations, or TEE-assisted modules), oMCP enables composable, auditable AI reasoning that dApps can invoke natively.
1. Introduction
AI systems are context-driven, whereas dApps are verification-driven. Bridging these paradigms requires a way for agents to discover tools on chain, compose context with live state, and return results with verifiability. oMCP addresses this by standardizing how smart-contract tools are registered and exposed to agents; how agents query chain data and decentralized storage; and how off-chain inference or real-world data can be anchored back on chain with proofs or agreement. Relative to prior oracle-only designs, oMCP elevates the context + invocation surface itself into a protocol that agents can reason about and reuse.
2. Design Goals and Contributions
(G1) Dynamic discoverability. Contracts are pre-registered with ABIs; an MCP server advertises a capability list so agents need not hard-code integrations. A server-side code generator emits service modules that map contract functions to invocable “tools.” Contribution: decouples agent logic from specific contracts while preserving typed interfaces.
(G2) Rich model context. Beyond function calls, agents require chain state, historical logs, and documents (e.g., whitepapers, metadata) to condition inference. oMCP extends access to on-chain queries, decentralized storage (IPFS/Arweave), and oracle inputs to enrich the model context available at inference time.
(G3) Developer ergonomics. SDKs (e.g., Python/TypeScript) abstract protocol details and data formatting for DeFi/NFT/dID scenarios, lowering time-to-integration.
(G4) Verifiability options. oMCP is compatible with multiple verification routes—zk proof systems for ML inference, decentralized oracle attestations, or TEE-assisted execution—so applications can choose the right trust-performance point. (arXiv)
3. Architecture and Implementation Phases
The development of oMCP can be understood as an iterative research program, structured into four phases. Each phase expands the system’s functional surface while also surfacing new challenges in verifiability, scalability, and developer adoption.
Phase 1 — Core Infrastructure and Registration Protocol
The first phase establishes the minimal primitives necessary for agents to interact with smart contracts dynamically.
Contract & ABI Registration: Smart contracts register themselves with an MCP server, publishing ABI interfaces and metadata. This allows automatic generation of service modules so agents can discover callable functions without preprogramming.
Capability Lists: A standardized discovery protocol enumerates available tools, signatures, and access rules. Agents query this list to construct context windows dynamically.
Dynamic Invocation: Agents call functions through the MCP host↔server channel, which mediates parameter passing and type-checking.
Research Insight: This phase addresses the “rigid coupling” problem observed in early AI–Web3 integrations, where agents were forced to hard-code tools. oMCP introduces dynamic binding similar to service discovery in distributed systems.
Phase 2 — Expanded Web3 Data Access and SDK Layer
The second phase broadens the contextual bandwidth available to agents.
State Queries: Beyond function calls, oMCP supports queries for balances, storage slots, event logs, and historical transactions.
Decentralized Storage: Integration with IPFS and Arweave allows persistent content such as metadata or whitepapers to become part of the model context.
Oracle Bridges: Off-chain data (e.g., prices, external events) enters oMCP through standardized oracle interfaces.
SDK v1.0: Multi-language SDKs (Python/TypeScript) abstract discovery and invocation for developers, enabling integration in DeFi, NFT, or decentralized identity workflows.
Research Insight: This phase resonates with distributed database systems, where query languages abstract away underlying storage heterogeneity. By exposing richer data layers, oMCP allows agents to ground their reasoning in domain-specific, high-value context.
Phase 3 — Operational Hardening and Security Extensions
As oMCP is integrated into real-world applications, the need for trust and governance arises.
Identity & Permissioning: Introduction of authenticated tool invocation and permission scopes to prevent misuse.
Multi-Signature Wallets: Support for custodial workflows where multiple parties control sensitive agents.
Auditing and Governance Hooks: Tools for tracking provenance and ensuring accountable usage of context modules.
TEE Integration: Exploration of Trusted Execution Environments (e.g., Intel SGX, ARM TrustZone) for handling sensitive computations and confidential model inputs.
Research Insight: This phase maps closely to the literature on secure computation platforms (e.g., Ekiden, Town Crier), where enclave-backed execution adds confidentiality and integrity. It highlights the trade-offs between hardware trust assumptions and proof-based systems like zkML.
Phase 4 — Multi-Chain Expansion and Ecosystem Integration
The final phase focuses on scaling oMCP across ecosystems.
Cross-Chain Registries: Decentralized registries allow contracts on different blockchains to be uniformly discoverable.
Universal Packaging: Legacy contracts can be wrapped into standardized schemas, ensuring backward compatibility.
On-Chain Proxies: One-click proxy contracts enable frictionless registration for developers, minimizing integration cost.
Marketplace Integration: Agents, plugins, and context modules can be published and reused across ecosystems via Studio and Launchpads.
Research Insight: This phase reflects broader trends in cross-chain interoperability research, where universal schemas and registries attempt to unify fragmented ecosystems. For oMCP, the key contribution is to ensure that contextual intelligence is portable and composable across chains.
4. Verification Layer: Options and Trade-offs
zkML proofs. Zero-knowledge proof systems can attest that an ML model ran correctly on a given input—useful for sensitive or high-impact decisions. The literature details proof-system choices, prover/verifier costs, and emerging frameworks for verifiable inference. (arXiv)
Decentralized oracle attestations. TLS-anchored proofs (e.g., DECO) attest to the authenticity of off-chain data without trusted servers, offering an alternative to TEE-only designs and enabling selective disclosure. (ACM Digital Library)
TEE-assisted execution. Systems like Ekiden explore enclave-backed confidentiality and integrity for smart-contract computation; TEEs can also underpin authenticated data feeds (e.g., Town Crier), with known deployment considerations. (arXiv)
Implication. oMCP does not mandate a single trust primitive; instead it parameterizes verification, so developers pick per-use-case balances between latency, cost, and assurance.
5. Context Composition & Agent Orchestration
oMCP’s discovery and context surface is orthogonal to any specific agent framework. Multi-agent patterns (task planners, tool-users, reviewers) can be layered atop oMCP so that agents first retrieve context (state/logs/docs) then invoke tools and ground model outputs back on chain. The literature on multi-agent LLM systems motivates these designs and suggests evaluation protocols for cooperative agents. (arXiv)
6. Applications (Illustrative)
DeFi risk & operations. Score collateral health by combining vault state, market context, and oracle prices; trigger on-chain mitigations when thresholds are crossed.
Governance intelligence. Summarize proposals with historical participation logs and sentiment context retrieved via oMCP, then anchor results for auditability.
Asset and identity services. Compose NFT metadata/documents from decentralized storage with contract calls to deliver verifiable profile enrichment and content workflows.
7. Research Directions
Context schemas & universal tooling. Formalize schemas for reusable context modules and tool metadata (costs, side effects) across chains; extend the “universal packaging” line toward static analysis of legacy ABIs.
Proof-efficiency for inference. Reduce prover time and proof sizes for practical zkML in production agent loops. (arXiv)
Hybrid verification paths. Combine zk attestations with TEE anchoring or oracle proofs to optimize for latency vs. assurance per workflow segment. (ACM Digital Library)
On-chain proxies & registries. Finalize one-click registration and decentralized registries for cross-chain discoverability and lifecycle governance.
8. Conclusion
oMCP reframes the AI-on-chain problem around model context as an auditable, composable resource. By coupling dynamic tool discovery and rich context access with configurable verification, it provides a pragmatic path from today’s siloed AI/dApp stacks to autonomous, verifiable agent workflows that dApps can trust and act upon. The phased roadmap—core infra → data/SDK → operational hardening → multi-chain/registries—maps cleanly to deployment realities and positions oMCP as a foundation for the next wave of intelligent Web3 systems.
References
Ghodsi, A., Ruan, K., et al. (2023). Zero-Knowledge Machine Learning: From Proof-of-Concept to Scalable Protocols. arXiv:2303.01063.
Ruan, Y., et al. (2024). zkML: Verifiable Machine Learning Inference via Zero-Knowledge Proofs. IEEE Security & Privacy Workshops.
Juels, A., Kosba, A., & Shi, E. (2016). The Ring of Gyges: Investigating the Future of Criminal Smart Contracts. ACM CCS.
Cheng, R., et al. (2019). Ekiden: A Platform for Confidentiality-Preserving, Trustworthy, and Performant Smart Contracts. EuroSys.
Zhang, F., Cecchetti, E., Juels, A., & Shi, E. (2016). Town Crier: An Authenticated Data Feed for Smart Contracts. ACM CCS.
Wooldridge, M. (2009). An Introduction to MultiAgent Systems. Wiley.
Russell, S., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach (4th Edition). Pearson.
Last updated