Vitalik Showed AI Acting Onchain. GT Protocol Opens MCP for Trading.
Vitalik Buterin recently published Billboard, an Aztec-based experiment where an AI model acts as a working component of an onchain application — it reads the post, checks a moderation policy stored onchain, decides whether the content is allowed, and hands the result to a system that can execute a permitted onchain action. The same pattern — model reads context, picks a tool, external infrastructure executes — is what GT Protocol now exposes for trading through an open MCP server.
There is no partnership, endorsement, or technical integration between GT Protocol, Vitalik Buterin, and Aztec. The connection is architectural. Billboard shows AI participating in an application’s operation. GT Protocol’s MCP server lets AI agents participate in trading in the same way: with defined data, defined permissions, and a limited set of executable tools.
This article walks through what changed with Billboard, why agent architecture matters more than any single model release, and what developers can build on the GT Protocol side. If you want to skip ahead and start wiring an agent to trading tools, the developer surface is available at app.gt-protocol.io.
What Vitalik’s Billboard experiment actually showed
Billboard is a small onchain application on Aztec where an AI model plays an operational role rather than a decorative one. When a post arrives, the model receives the content, reads a moderation policy that lives onchain, evaluates the post against that policy, and returns a decision. The system then calls a predefined onchain command based on that decision. The model does not run the chain, hold funds, or invent actions. It reads context and selects one of the actions the application permits. That is the shift Billboard demonstrates: AI moves from generating text a human then acts on, to being the component that decides which of a fixed set of permitted actions should run next.
It matters because it validates a pattern rather than a product. The interesting part is not moderation on Aztec. The interesting part is the shape: context in, tool out, external system executes. Anything that can be reduced to that shape can host an AI agent as an operational component — moderation, routing, treasury policy, and, as we’ll show, trading.
Why an AI agent is not a longer prompt
Most public conversation still treats “AI agent” as a synonym for a chatbot with better instructions. It is not. An agent is a system with four parts, and if any part is missing, it stops being an agent.
First, data: what the model is allowed to read — balances, prices, open positions, policy files, on-chain state. Second, permissions: what the agent is allowed to touch, where, and up to what limit. Third, tools: the concrete, structured actions the agent can call — not free-form text, but named functions with defined parameters and defined outputs. Fourth, execution: the external infrastructure that actually runs the action after the model selects it. The model is only the reasoning layer. It picks. The execution layer decides whether the pick is valid and carries it out. Billboard is a working instance of this four-part structure. A pure prompt-based chatbot is not.
MCP: the connective tissue between model and infrastructure
Model Context Protocol (MCP) is an open standard for how AI clients talk to external systems. MCP refers to the layer that lets a compatible AI client understand which tools are available on a server, which parameters each tool accepts, how to call a specific function, and what structured result the system will return.
Before MCP, every integration between an AI model and an external application was custom: bespoke prompts, bespoke parsers, bespoke error handling. Each new tool required rewiring on both sides. MCP replaces that with a stable contract. The server describes its tools once. Any MCP-aware client — Claude Desktop, an IDE assistant, a purpose-built trading agent — can discover those tools, call them safely, and interpret the results. For developers, this collapses weeks of glue code into a connection step. For end users, it means the AI they already talk to can pick up new capabilities without a new interface.
MCP does not decide anything. It does not hold opinions about strategy, risk, or markets. It carries structured requests from a reasoning layer to an execution layer, and structured answers back.
What GT Protocol opens for AI trading agents
GT Protocol provides developers with an open MCP server and a Trading API that together let an AI agent operate as a working component of a trading system. The agent brings the reasoning. GT Protocol brings the tools and the execution layer. The Trading API uses the same engine as the GT App and supports the Binance and Hyperliquid workflows described in the official product materials.
The available tools group into four intents:
- READ — check balances, list strategies, read past and open positions. The agent needs to know the state of the account before it proposes anything.
- TEST — run a strategy against historical market data. The agent can validate an idea before committing capital.
- TRADE — create strategies, start them, update their settings, stop them. This is where the agent’s decisions leave the model and enter the market.
- MANAGE — open and close individual deals, and interact with supported CEX and DEX environments (Binance and Hyperliquid today).
The developer decides which of these the agent may use, on which account, and under what limits. The model does not invent trades in raw natural language. It selects from tools with defined parameters, and the execution layer either accepts the call or rejects it.
The same pattern, applied to two different problems
Billboard and a GT Protocol trading agent look very different on the surface — one moderates posts on Aztec, the other manages positions on centralized and decentralized exchanges. Underneath, they run the same loop.
In Billboard, the model reads a post plus a moderation policy, selects a moderation action from the permitted set, and hands the call to the onchain executor. In a GT Protocol agent, the model reads balances, open positions, and market context, selects an action from the permitted trading tools (create a strategy, start it, close a deal), and hands the call to the GT execution layer. In both cases the model’s job is analysis and action selection. It never touches the underlying infrastructure directly. Permissions and tool definitions are what keep the system safe — not the model’s good behavior. That’s the pattern that lets AI participate in real applications without turning them into unbounded experiments.
What a developer can build
The value of an open MCP server is not that it does one thing well. It’s that developers can compose the tools into workflows the platform team never anticipated.
A research agent reads the account’s deal history, notices which strategy configurations have worked, and drafts variations for a human to approve. A market-monitoring agent watches Binance and Hyperliquid conditions and pauses live strategies when volatility crosses a threshold. A portfolio agent takes a natural-language instruction (“rebalance toward lower drawdown”) and translates it into a series of stop and create calls. A backtest agent iterates through parameter ranges on historical data and reports which configurations are worth testing on demo before going live.
None of these agents need to be built by GT Protocol. The MCP server exposes the primitives. The developer defines the agent’s logic, its restrictions, and the actions it is allowed to take. Backtests and automation do not guarantee future returns — they are tools for reducing surprise, not for eliminating it.
Where this is going
Two things are becoming clear at the same time. First, general-purpose LLMs are catching up to the point where reasoning quality is no longer the scarce resource. Second, the applications where AI can actually do things — not just discuss them — are gated by whether the underlying infrastructure exposes a clean tool interface.
Billboard is a small experiment, but it’s an unusually clear demonstration of the ceiling being raised: the model isn’t the demo, the loop is. GT Protocol’s MCP server is the same claim on the trading side. If you build agents, the interesting question stops being “which model?” and becomes “what tools does the agent have, and how tight are the permissions around them?”
Frequently Asked Questions
Is there a partnership between GT Protocol, Vitalik Buterin, or Aztec?
No. There is no partnership, endorsement, or technical integration. Billboard is referenced in this article as a public illustration of AI acting as an operational component of an application. The connection to GT Protocol is architectural — the same agent pattern applied to a different domain.
What is MCP?
MCP (Model Context Protocol) is an open standard for how AI clients discover and call tools exposed by external systems. It defines how a compatible AI client learns which tools are available, what parameters each accepts, how to invoke them, and what structured result to expect.
What can an AI agent do through the GT Protocol MCP server?
Through the available tools, an agent can read account state (balances, strategies, deals), test strategies against historical data, create and control trading strategies, and open or close individual deals on supported exchanges. The developer decides which of these actions the agent is allowed to take.
Which exchanges are supported?
The Trading API supports the Binance and Hyperliquid workflows described in the official GT Protocol product materials.
Does the AI model execute trades directly?
No. The model’s role is analysis and action selection. When it selects a trading action, that call goes to the GT Protocol execution layer, which validates it against the account’s permissions and routes it to the exchange. The model never touches the exchange directly.
Do I need to be a professional developer to use this?
The MCP server is aimed at developers and technical teams building AI agents. If you want to trade with automation without building your own agent, the GT App exposes the same trading engine through a standard interface.
Does automation guarantee returns?
No. Backtests describe past market behavior. Live automation reduces the friction and delay of manual execution but does not remove market risk. Any agent built on this infrastructure inherits the underlying market conditions of the exchanges it trades on.
Build with it
The pattern Vitalik demonstrated with Billboard — AI as a bounded operational component of a real application — is the same pattern developers can now apply to trading with GT Protocol. The reasoning layer is the model you choose. The execution layer, the tools, and the exchange connectivity are what we provide.