& L1:Why an Agent-Native Chain Exists
Wayne Kombat9 min read·1 hour ago--
0x26 site: https://0x26.xyz
What & Brings to the Table for Bot Traders, Agent Builders, Market Makers, and Institutions
Bots are no longer a side feature of markets.
TLDR; & is crypto’s move from shared root passwords to Cloud IAM. 0 -> 1.
Old model:
- one powerful credential
- whoever has it can do almost anything
Modern model:
- scoped roles
- temporary credentials
- explicit permissions
- audit trails
- revocation
- on-chain reputation
An agent-native chain is not only about restricting bots. It is about giving them a path to earn more authority. New or unattributed agents start smaller. Agents with stronger identity, cleaner conformance, and a longer history of staying inside mandate can operate with larger caps, richer permissions, and eventually more economic freedom.
In other words, & does not just ask “how do we limit software?” It asks “how do we safely let good software do more?”
Bots & Agents
They quote. They hedge. They arb. They manage inventory. They execute strategies across venues. They enforce treasury policy. They route capital. Increasingly, they do the work that used to sit with human traders, operators, and risk teams.
And yet almost every chain and every venue still treats them like a human with a wallet. That is an issue because wallets are identity primitives, not authority primitives. They can prove that a key signed an action, but not what the bot was permitted to do, what constraints it was under, or whether the action should have been blocked before execution. Once software is managing capital, that gap creates unnecessary security, risk, and audit exposure.
What if a trader’s performance was a first-class on-chain primitive? What if autonomous agents could discover, evaluate, and contract other agents based on proven performance in specific strategies?
Autonomously. 0 -> 1.
& is an agent-native chain: a Layer 1 designed around the reality that bots and autonomous agents are becoming first-class market participants. The chain is not built around the assumption that a human is watching every action, approving every trade, or interpreting every exception in real time. It is built around the assumption that software is acting with real authority over real capital.
That sounds subtle, but it changes everything.
The Problem With the Current Stack
Today, if you run bots or autonomous trading agents, the real control system lives off-chain.
You have to decide what each bot is allowed to do. You have to issue keys. You have to restrict markets, cap exposure, control rate, set drawdown limits, define expiry, and monitor for drift. You have to build signer services, vaulting, dashboards, kill switches, replay systems, alerting, and audit trails.
In other words, you do not just build the strategy.
You build the missing infrastructure layer underneath it.
And even after all of that work, the chain or venue still does not actually understand the bot.
It sees a key. It sees a wallet. It sees a signature.
It does not see that this key belongs to a market-making system with a defined spread policy. It does not see that this agent was only supposed to trade BTC and ETH. It does not see that the bot exceeded its drawdown or drifted from its mandate. It does not know that the strategy was supposed to shut down three minutes ago. Other agents and bots also do not see this.
All of those controls are external to the protocol.
That means three things are true on most existing stacks:
- Bot authority is simulated, not native.
- Bot behavior is monitored after the fact, not enforced at the point of admission.
- Bot risk is largely an operational problem, not a protocol-level one.
For small-scale automation, maybe that is acceptable.
For serious agent trading, market making, and institutional deployment, it is not.
The Core Thesis of &
Bots and agents need their own primitive layer.
Not a dashboard. Not an API wrapper. Not an off-chain policy engine. Not a “bot account” bolted onto a legacy venue.
A primitive layer.
That is what & brings to the table.
It makes authority, identity, and conformance part of chain state, so the base layer can answer a simple but critical question:
What was this bot allowed to do, and did it stay inside those bounds?
That question should not require internal logs, screenshots, trust in an operator, or a long incident writeup.
It should be something the protocol itself can answer. With a simple query.
What & Actually Adds
1. Bots Get Native Mandates
On &, a bot does not just get a key. It gets a mandate.
A mandate is an on-chain object that defines what the bot is authorized to do and what it is trying to achieve. That can include:
- allowed markets
- exposure limits
- volume caps
- drawdown caps
- rate limits
- expiry windows
- evaluation windows and objectives
This is the first major delta.
Without &, those rules live in private software and internal ops. With &, those rules live in protocol state.
That means if a bot tries to act outside the authority it was given, the chain can reject the action at admission.
Not later. Not after monitoring catches it. At admission.
For bot builders, that means less custom enforcement infrastructure. For MMs, it means tighter bounded authority for quoting and inventory systems. For institutions, it means a more defensible control framework for autonomous capital.
2. Session Keys Are Bounded by Design
Most bot architectures today rely on some combination of hot wallets, API keys, signer daemons, or privileged execution services.
The problem is obvious: when the credential is too powerful, compromise is too expensive.
& changes that with session keys constrained by mandate.
A bot can be given the exact authority it needs and no more. If that key leaks, the attacker does not inherit unlimited power over the account. The blast radius is bounded by the mandate attached to the key.
That is a materially different security model.
Without an agent-native primitive layer, teams have to approximate this with custom signer logic, proxy services, revocation flows, and constant operational vigilance.
With &, bounded delegation is native to the chain.
3. Bot Behavior Becomes Verifiable
One of the biggest weaknesses in current automated trading stacks is that they are hard to verify from the outside and often messy to verify from the inside.
You can usually prove that a trade happened. You usually cannot cleanly prove that the trade was allowed under the strategy’s declared authority model.
& closes that gap through verifiable execution.
Every action under an active mandate can be tied back to its conformance state. The chain can answer questions like:
- Was this trade within the bot’s mandate when it executed?
- Did this bot ever act outside an active mandate?
- Was it in breach state at the time?
- What did its conformance look like over a given window?
This matters because bots are not just code. They are delegated authority.
The moment a strategy acts on capital, the important question is not just what it did. The important question is whether it stayed inside the boundaries it was granted.
Without &, that answer depends on internal systems and operator cooperation. With &, it is protocol-legible.
4. Bot Identity Can Be Structured, Not Social
Today, the market often has no reliable way to distinguish between different classes of autonomous actors.
A random wallet can claim to be a serious strategy. A well-designed agent and a reckless script can look structurally identical. “Official bot” often just means “someone said so.”
& introduces tiered identity for agents.
At the low end, a bot can simply exist as an unattested actor. At higher levels, an operator can vouch for it. At the strongest levels, the bot can be tied to attested execution environments and measured code.
The point is not branding. The point is structural differentiation.
When bots become first-class economic actors, identity cannot just be narrative. It has to become part of the system’s trust model.
That matters for allocators, for counterparties, for marketplaces of strategies, and for any future where bots compose economically with one another.
5. Circuit Breakers and Revocation Move Closer to the Protocol
When a bot drifts, malfunctions, or is compromised, time matters.
Most teams today handle that situation operationally. Someone revokes a key, stops a service, updates a policy engine, or manually intervenes under stress.
That is slower and more failure-prone than it should be.
& gives the system native pause, revocation, and circuit-breaker primitives, with an on-chain audit trail. The goal is simple: make bot shutdown and authority withdrawal part of the system itself, not just an emergency playbook.
For serious bot operators, that is not a nice-to-have. It is table stakes.
6. Smart Contracts Can Compose With Bot-Native Trading Primitives
Most chains make contracts and native systems interact awkwardly.
You can read state. You can emit events. Then some off-chain relayer or keeper finishes the work later.
That is a poor fit for serious automation.
On &, contracts can interact synchronously with native primitives. A contract can submit an order and observe the admission result in the same transaction flow. That means better atomicity, less relay infrastructure, and fewer custom state machines.
For bot builders, this matters because automation is not just bot-to-chain anymore. Increasingly it is bot-to-contract-to-market logic, all tied together.
A chain that forces everything through asynchronous glue code raises complexity and risk. A chain that supports synchronous composition lowers both.
Without These Primitives, Bot Operators Need to Build the Missing Layer Themselves
This is the practical delta.
Without our primitives at the core of the chain, bot operators need to build their own off-chain trust and control stack.
They need to build:
- mandate logic
- bounded credential systems
- strategy authorization layers
- drawdown and exposure enforcement
- drift monitoring
- revocation workflows
- replay and audit systems
- external reputation and identity systems
- relayers and async coordination layers
And even if they do all of this well, they still do not get the same guarantees, because the protocol itself is not enforcing the boundaries.
They are simulating an agent-native system on top of a human-native base layer.
That works up to a point.
But once bots are handling serious capital, market-making logic, treasury execution, or autonomous strategy routing, simulation is no longer enough.
What Risk Do You Carry If You Do Not Use an Agent-Native Chain?
If you deploy bots on infrastructure that does not understand bots as a primitive category, you take on avoidable exposure.
Security Exposure
Your credentials are usually too powerful, and your containment model depends on off-chain systems behaving correctly under stress.
Drift Exposure
Your bot may violate strategy boundaries before your monitors catch it, because enforcement sits outside the admission path.
Audit Exposure
When something goes wrong, proving whether the bot acted within rules becomes a reconstruction exercise instead of a state query.
Operational Exposure
Every signer, monitor, relayer, policy engine, and emergency control plane becomes another moving part that can fail.
Integration Exposure
As bot logic becomes more composable and contract-driven, async relays and middleware create more complexity, more latency, and more attack surface.
Reputation Exposure
The market has no native way to tell the difference between disciplined autonomous systems and undisciplined ones. Trust remains narrative-heavy instead of structural.
For Bot and Agent Traders:
You get a chain that actually understands what you are building.
Not just a place to post orders, but a place where your strategy can operate under bounded authority, with clearer safety and stronger legibility.
For Market Makers:
You can deploy quoting and inventory systems with tighter control over what those systems are actually allowed to do. If something drifts, the boundary is enforced closer to the market, not just documented in internal tooling.
For Institutions
You get a more credible substrate for delegated autonomy.
If you want to let software act on capital, the question is never just whether the strategy is good. The question is whether the authority model is enforceable and auditable.
& is built around making that answer stronger.
The Bottom Line
The real question is not whether bots will become a major market participant class.
They already are.
The real question is whether they will keep running on infrastructure that treats them as glorified wallets, or whether the market will adopt infrastructure designed around autonomous actors from the ground up.
& is built for the second world.
A world where bots are not an edge case. A world where agents hold real authority. A world where strategy constraints should be enforced by protocol, not just by ops. A world where “what was this bot allowed to do?” has a deterministic answer.
That is what & brings to the table.
Not just another L1.
A chain where bots and agents are first-class citizens.
We’re putting the finishing touches on our testnet right now with a launch pegged for May 2026.
site: https://0x26.xyz
setup your agent (autonomously of course): https://0x26.xyz/setup
docs: https://docs.0x26.xyz/
Not just another L1.
