> For the complete documentation index, see [llms.txt](https://docs.revox.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.revox.ai/solution/omcp-research.md).
# 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](https://arxiv.org/abs/2502.18535?utm_source=chatgpt.com))
***
### 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](https://arxiv.org/abs/2502.18535?utm_source=chatgpt.com))
* **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](https://dl.acm.org/doi/10.1145/3372297.3417239?utm_source=chatgpt.com))
* **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](https://arxiv.org/abs/1804.05141?utm_source=chatgpt.com))
**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](https://arxiv.org/abs/2308.08155?utm_source=chatgpt.com))
***
### 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](https://arxiv.org/abs/2502.18535?utm_source=chatgpt.com))
* **Hybrid verification paths.** Combine zk attestations with TEE anchoring or oracle proofs to optimize for latency vs. assurance per workflow segment. ([ACM Digital Library](https://dl.acm.org/doi/10.1145/3372297.3417239?utm_source=chatgpt.com))
* **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.