Where we go
from here.
Maxim Protocol is a month old. The Anchor program is written, the SDKs are taking shape, and the dashboard is in beta testing. What follows is where we go from here, on the timeline we think we can hold ourselves to. We are publishing this because the people building on top of us deserve to know what we are working on, in what order, and why.
Phase one
Foundations
Phase two
Production readiness
Phase three
Ecosystem
Phase four
Longer horizons
Foundations
In progressSolana program
The Anchor code is feature complete for agent wallet registration, transaction recording, and basic policy enforcement. It is deployed to devnet and has been internally reviewed. Before it sees mainnet, it goes through an external audit with a firm we will name when the engagement is signed. Settlement code is the part of any system you want to over-audit rather than under-audit, and we will hold mainnet back until the audit clears, even if it costs us a few weeks of momentum.
SDK surface
The TypeScript SDK is the primary developer interface and ships first. The Python SDK follows within the same phase, since a large share of agent frameworks live in Python and we do not want to force teams to choose their language based on our shortcomings. Both SDKs cover x402 and MPP from day one, with a handler architecture that lets us add new protocols without breaking existing integrations.
Dashboard
The version in beta testing today shows agent inventory, request volume, cost per agent, cache performance, and policy events. Phase one closes when the dashboard moves to public beta and any team that signs up can see their agents and spend in real time.
Production readiness
Up nextPolicy engine
The first version enforces budget caps, domain allowlists, rate limits, and per-call ceilings. The next version adds time-window policies, multi-signature approval flows for transactions above a configurable threshold, and policy templates that teams can apply across fleets of agents without rewriting them per agent. Policy is the layer that turns autonomous agents from a liability into something a finance team can actually approve, and we treat it accordingly.
Operator surface
Structured webhooks for payment events, an audit log API that finance and compliance teams can wire into their own systems, role-based access control on the dashboard, and a CLI that covers every action available in the UI. Anything you can do by clicking, you should be able to do from a terminal or a script.
Observability
We will publish a public status page covering gateway uptime, settlement latency, and per-protocol success rates. We will also expose a metrics endpoint that teams can scrape into their own monitoring stacks. Infrastructure you depend on should be transparent about how it is performing, not opaque.
Ecosystem
PlannedProtocol support
We are watching ACP, AP2, and AMP closely. The architecture is built so that adding a new protocol is a matter of writing a handler, not changing the SDK contract. As any of these protocols gain real adoption, we will add them. We are not going to chase every specification that gets published, but we will be honest about what we support and what is in flight on a public protocol support page.
Chain strategy
Solana is where the agent payment volume is today, and the economics and finality are what make sub-cent settlement possible. We are not planning multi-chain support in 2027. If the market changes, we will revisit. We would rather do one chain well than four chains adequately.
Developer floor
Reference implementations for common agent patterns, including a paying research agent, a metered API consumer, and an agent that hires sub-agents and accounts for their work. We will also open a public bug bounty once the external audit is complete, with payouts scaled to severity.
Longer horizons
On the horizonAgent reputation
When an agent has a payment history that is verifiable on-chain, counterparties can decide whether to extend credit, offer discounts, or require pre-payment. We do not need to build a reputation system ourselves for this to work. We need to make sure the on-chain ledger is rich enough that someone else can.
Escrow and milestone payments
Today, agent payments are mostly single-shot. As agents take on longer running tasks, the contracting pattern between them will look more like freelance work and less like API calls. The on-chain primitives need to support that.
Compliance frameworks
We expect compliance frameworks for agent payments to land within the next two years. When they do, Maxim Protocol will need to support whatever attestation, identity, and reporting requirements emerge. We are tracking this and designing the policy engine with that future in mind, even though the current requirements are minimal.
If you are building agents that need to pay for things, the work above is the work we are doing for you.