Why developer infrastructure for AI coding agents has to be built differently, and how the MvX Agent Hub provides it
Documentation is read by whoever writes the code. For most of programmable systems’ history, that reader was a developer. In 2026, increasingly, it is an AI coding agent: fetching tool definitions, generating code against them, and submitting transactions on the developer’s behalf.
The reader has changed.
MultiversX is engineered for agent workloads at the runtime layer. Supernova brings sub-second finality inside the agent’s decision cycle. Payment rails clear at the same speed. Identity and trust are composable in a single transaction. That substrate still has to be built on by somebody. The audience that is now doing the building reads documentation differently.
Every editor ships with an agent
Every major development environment has shipped AI collaboration as a default surface. Cursor and Windsurf rebuilt the editor around an agent in the loop. GitHub Copilot moved from autocomplete to agent mode. Claude Code and Codex ship as standalone agentic environments, with Codex now integrated as ChatGPT’s built-in coding agent.
The shift is in usage patterns, not announcements. A 2026 developer building on any non-trivial system does so with a coding agent as the primary author and the human as the reviewer.
Most chains present themselves through documentation that the new reader cannot use well. Code generated against narrative documentation is plausible-looking and structurally wrong. API calls drift from the actual signatures. Conventions mix patterns from different chains. Edge cases live three pages away from the example. The chain a coding agent ends up building on is the chain it can read.
Where the docs break
Hierarchical documentation assumes a reader who builds context from earlier pages and carries it forward. A coding agent retrieves only the page relevant to the immediate task. Cross-page context is lost. Every page has to stand on its own, with conventions and anti-patterns embedded at the point of use.
SDK examples assume a developer who reads, understands what the example demonstrates, and adapts it. A coding agent extracts the pattern and generates against it directly. Examples that elide imports or depend on context established three pages earlier produce code that compiles into bugs. The example has to be self-contained enough to be transcribed cleanly.
Tutorial-style guides assume the reader is learning the system. A coding agent is not learning. It is generating. It needs the rule, not the pedagogy. “Always use the synchronous cross-contract storage read pattern for same-shard calls” is more useful than three paragraphs explaining why.
This is not a documentation quality problem. The same docs that serve human readers well can fail agentic readers completely. Documentation written for one audience does not automatically serve another.
Chain meets agent
The Agent Hub at multiversx.com/ai consists of three distinct systems. Each addresses a different part of what an AI coding agent needs from a chain. They are routinely conflated. They do not do the same thing.
MCP gives an agent hands. The MultiversX MCP server exposes the network’s onchain capabilities as structured tools through the Model Context Protocol. An agent running on Claude, Cursor, or any MCP-compatible client calls those tools to check balances, transfer EGLD, issue tokens, mint NFTs, or query network state, without MultiversX-specific training. The tools follow MCP’s standard schema. Agents discover and invoke them the same way they handle any other tool in the environment. The chain becomes one more capability in the agent’s toolkit.
Skills give an agent knowledge. The mx-ai-skills repository installs modular skill files into the agent’s coding environment. Each file packages expertise on one MultiversX topic: smart contract patterns, audit conventions, gas optimization, static analysis, dApp frontend, scenario testing. The skills do not execute. They constrain. An agent asked to write a MultiversX smart contract loads the relevant skills and writes code that matches the chain’s actual conventions instead of patterns imported from another ecosystem. A set of workflow files configures the agent as a specific role: Rust contract developer, security auditor, dApp architect, each with its own constraint surface.
Agent Kit gives an agent a runtime. The mx-agent-kit is the framework for deploying autonomous agents that operate continuously as their own services, beyond what an AI assistant writing code provides. It is built on the Eliza agent framework and Portkey’s AI Gateway, with native integration to OpenAI Swarm, LlamaIndex, LangChain, LangGraph, AutoGen, CrewAI, and Phidata. An agent deployed through the Kit is a process running in its own right: long-lived, network-addressable, with its own identity onchain.
The mental model is simple. MCP is how an agent does blockchain things. Skills are how an agent writes correct MultiversX code. Agent Kit is how an agent runs as its own service. Hands, knowledge, runtime.
Before the code
The skills repository opens with a behavioral rule that gets injected into the agent’s context before any code is generated. Verbatim, as it appears in the skill files:
Always ask for clarification when uncertain.
Domain-specific constraints follow. Arithmetic safety with checked operations only. Strict adherence to the Checks-Effects-Interactions pattern. Security prioritized over convenience. The first rule applies to behavior. The others apply to code.
Constraint injection before generation is what reduces hallucination rates. The agent writes inside a context that explicitly forbids guessing and requires clarification when uncertainty appears. The skills are the constraint surface; the persona files determine which constraints apply for which role.
The same principle runs through the MCP layer. Each tool exposes typed parameters, structured return values, and explicit error states. An agent invoking the tool cannot misinterpret what it returns. The interface is machine-legible without ambiguity, the same property the skills enforce on the generated code.
One legibility principle, two surfaces. The invocation interface is constrained. The code generation is constrained. The chain is legible to agents at both ends of the loop.
Three commands to a live agent
OpenClaw is the deployment template that composes everything. From the Agent Hub:
What runs is the OpenClaw platform installation, the MultiversX skills load, the agent wallet generation, VPS provisioning with SSL and firewall and health checks, and onchain identity registration through MX-8004. The deployment produces an Express API, a Next.js frontend, wallet integration, and a registered onchain identity. The agent can swap tokens, transfer EGLD, stake, and mint NFTs from the moment it goes live.
The time between deciding to build an agent and having one running onchain is on the order of minutes. What this consumes is what the chain already ships at the protocol layer: sub-second finality, gasless transactions through Relayed v3, MX-8004 identity. The Agent Hub is the interface that makes those primitives usable to the audience now doing the building.
What this opens
Max was a light proof of concept. Running on devnet, Max executed a Mystery Swap flow. A user connected a wallet and chose an amount. Max pulled live token data from xExchange, decided the token allocation autonomously, executed swaps against live liquidity, and returned the purchased tokens to the user’s wallet. No human in the loop on the agent’s side. The full stack composed in one interaction: discovery, authorization, execution, settlement, identity. A second mode exposed the same agent identity as a conversational chatbot.
The broader pattern is what matters. When the chain is legible to AI coding agents, the time and skill required to build on it collapses. A developer with an idea and access to a coding agent can produce a deployed onchain service in an afternoon. A specialist domain agent for a specific protocol becomes a feasible weekend project. The set of people who can build agentic services on the chain widens by orders of magnitude.
An agent generating code that uses MX-8004 identity or MPP payment rails reads from the same skills surface that teaches contract patterns and gas optimization. The constraint surface covers every primitive the chain exposes.
What that opens is more agents. The deeper change is a different developer surface, one where the friction between idea and deployment runs at the speed of the agent doing the building rather than the speed of the human reading the docs. The chains that exist inside that surface are the chains that get the agents built on them.
What’s live
The Agent Hub is live at multiversx.com/ai. The MCP server, the skills repository, the Agent Kit, and the OpenClaw template are open source. The Agent Explorer at agents.multiversx.com shows registered agents and the onchain jobs they have completed, with the registry sitting on MX-8004 identity contracts.
Anyone can clone the OpenClaw template, deploy an agent, and watch it register in minutes. A live, browsable agent network exists, on a real chain, with real onchain state, attached to real identity primitives.
A chain you can read
The chain has to be legible to whoever is writing the code. In 2026, that is increasingly an AI coding agent operating on behalf of a human developer, and the documentation, SDKs, and runtime infrastructure it reads are not the same artifacts a human reader needs.
Machine-readable tool definitions so the chain can be invoked. Structured constraints so the code that gets generated is correct. A runtime framework so the agents that get built can operate as services in their own right.
With the surface built for agents and agentic development, Supernova will add the runtime: speed, composability, scalability.
