Skip to main content
Intention is a Layer 1 blockchain for open markets, with native capabilities for AI agents built into the protocol. Matching, risk, clearing, and price integration are not applications deployed on top of a general-purpose virtual machine. They are first-class operations of the protocol itself, executed inside a deterministic state-transition kernel and finalized by Byzantine-fault-tolerant consensus. The trading venue is the chain. That is two things at once. For human traders and integrators, it is an open, public, professional venue: a high-performance perpetual futures DEX with a full central limit order book, professional order types, isolated and cross margin, protocol-native liquidations, and on-chain liquidity vaults — running on a chain that anyone can audit, replay, and build on. For autonomous agents, it is something more fundamental: a substrate where the venue itself is legible, where the chain is not a noisy oracle to guess at but a function that can be inspected and acted on at block cadence. The first application running on Intention is Intention Exchange — a perpetual futures DEX, live at app.intention.xyz, that inherits its matching engine, risk pipeline, and pricing guarantees from the L1 by virtue of running on it. The same substrate is designed to host other order-book markets — including tokenized real-world assets — without changing the execution model.

​
Open by asset, AI-native by protocol

Most chains were designed for human users, where opacity and probabilistic execution are tolerable because a human is in the loop to react. That makes them awkward for serious traders and unworkable for autonomous agents. Matching priority is at the mercy of block-producer reordering. Mark prices live on a different cycle than execution. Liquidations are keeper races. Per-transaction effects are reconstructible only via third-party indexers. Intention removes that opacity. Every block on Intention satisfies four invariants by construction:
  • The block is byte-deterministic — any honest replay produces identical state and identical per-transaction outputs.
  • The price used to settle each transaction is certified in the same consensus event that committed the transaction.
  • Risk is a protocol state machine — mark pricing, liquidations, ADL, insurance, and funding execute atomically with matching, in the same block, under the same prices.
  • Every state change is cryptographically bound to the user transaction that caused it.
For a human trader, these properties produce a fairer venue: ordering you can audit, prices you can verify, liquidations that follow protocol rules instead of off-chain races, and a per-trade attribution trail that exists at the protocol level rather than in someone else’s database. For an autonomous agent, the same properties produce something more: an environment that can be reasoned about with the same rigor an agent applies to its own internal state. The chain becomes a function the agent can inspect. The Intelligence Layer page covers the AI-native side in detail — the four agent capabilities the protocol is shaped to host, and how each maps to one of the guarantees below.

​
Four protocol-native guarantees

These are not best-effort properties of an application. They are properties the protocol enforces and that any honest validator can replay.

Order-Time Determinism (OTD)

Replaying a finalized block produces byte-identical state, events, and per-transaction outputs on every honest node.

Price-Transaction Atomicity (PTA)

The price used to settle a transaction was certified by the same 2f+12f+1 validator quorum that committed the transaction.

Risk-Native Semantics (RNS)

Mark pricing, liquidations, insurance, ADL, and funding run as protocol state machines in the same atomic context as matching.

Per-Transaction Attribution (PTAD)

Every state change and event is cryptographically bound to the user transaction that caused it, even under batch matching.
The four are coupled. PTA depends on OTD; RNS depends on PTA; PTAD depends on both. Together they remove the entire class of “off-chain matching with on-chain settlement” hacks that other on-chain perpetual venues have relied on, and they make the trading engine itself auditable rather than the activity around it.

​
Where to go next

Architecture overview

The asset, infrastructure, and intelligence layers, and how IntentionKernel and IntentionBFT compose into the four guarantees.

Intelligence Layer

What the protocol enables for autonomous agents, and how the four guarantees translate into AI-native capabilities.

Trading overview

Markets, order types, margin modes, mark pricing, and the full lifecycle of a perpetual futures position.

API Reference

REST, WebSocket, and node integration tracks for human and machine integrators.

​
Status

Intention is under active development. Several pages in this site describe behavior that the protocol guarantees by design but that has not yet been exposed through a public mainnet UI or API. Those pages are clearly marked. The architecture, trading mechanics, and risk-and-security sections describe the system as it is being built; the get-started and API-reference sections are largely placeholders pending mainnet launch.
No native token currently exists. Documentation does not describe tokenomics, staking incentives, or any token sale. Token-related material will be published only after the asset is live.
For the long-form rationale and proofs behind the four guarantees, the Intention whitepaper is available on request from contact@intention.xyz. For other questions, write to the same address.