Building Delphi: Pricing, Settlement, and Agentic Trading

An information market is a world model priced in capital. Every trade aggregates a piece of information into a price and the economic pressure behind that number is what makes it worth anything.

But open versions break in three specific ways: pricing mechanisms need either a loss-absorbing market maker or a counterparty that may not be present, settlement is either slow and capture-prone or asks you to trust the operator, and systems built for humans tend to be less friendly to the programmatic participants who provide the most active liquidity.

Delphi represents a specific design choice on each of these three axes.

Pricing: dynamic pari-mutuel

The two dominant pricing mechanisms in on-chain information markets, LMSR-family AMMs and central limit order books, both struggle in the long tail.

LMSR needs initial liquidity and the entity that provides it often loses money. That is workable when a platform absorbs the loss for a small set of curated markets but it does not generalise. Order books fail in the opposite direction: they need someone on the other side of every trade which in a thin market is often nobody.

We picked a dynamic pari-mutuel cost function instead. Pari-mutuel pools have been used in betting for over a century, payouts are funded entirely by the pool, so the operator is structurally solvent but classical pari-mutuel only quotes a single price at close, which makes early trading guesswork. The dynamic version preserves the pool-solvent payout structure while quoting a continuous price during trading, derived from the share supply across outcomes. As one side accumulates more demand, the marginal cost of buying that side rises and the implied payout adjusts continuously.

The creator picks any non-zero initial liquidity and keeps a position in the market. Their worst case is losing a portion of that initial deposit; in many markets they end up profiting on those locked shares.

Each market is deployed via a factory as its own non-upgradeable contract. We can moderate what appears in the app but we cannot rewrite a market after launch; it continues to live on-chain according to its rules.

The contracts were audited by Trail of Bits over months and across multiple review cycles. Every piece of the system - the cost function, the market lifecycle, the factory architecture, the gateway interfaces - was reviewed line by line. Full audit reports will be published with the technical writeup.

Settlement: a tiered AI judge

Settlement is where information markets earn or lose their credibility.

There are three real options for resolving an arbitrary natural-language market. Human committees are slow, capturable, and expensive. Optimistic-oracle staking models like UMA are slow by construction, operationally heavy, and capital-inefficient at the long tail. AI judges are fast and cheap but in a closed system they ask you to trust the operator.

Stepping back, the only thing that scales here is a trustworthy intelligent oracle: a neutral model that reads real-world sources and draws a conclusion from evidence - judging what's already happened, not predicting what's to come. AI judges are the right primitive, the work is making them trustworthy.

The result is a tiered settlement path that lets the creator trade speed for verifiability:

• Foundation models. Fast, capable across a wide range of question types, and good enough to settle the long tail of markets without ceremony. The creator picks the model from a curated list with sensible defaults.
• REE. The verifiable path. Open-source models running inside REE, Gensyn's Reproducible Execution Environment, produce a receipt that can be independently rerun to verify the answer. If a result is questioned, the receipt gives people a reproducible run to inspect instead of asking them to accept a black-box answer. REE markets settle a little slower in exchange for a property no closed system can match: anyone, anywhere, can verify the result themselves.
• Hosted REE. Creators outsource REE settlement to dedicated infrastructure providers. This offers verifiability without requiring creators to operate the stack themselves.

Trustworthy isn't a property of the model alone. It's a property of the model plus what you feed it.

Creators should write the prompts that settle their own markets. They know the question and the edge cases better than the platform does. But writing a good prompt for an AI judge is a skill and Testnet showed us that the cheapest way to get a wrong settlement is a vague prompt. So we built scaffolding. Settlement prompts are written by the creator but they start from category-aware templates split across Sports, Politics, Crypto, Economics, Science, and Culture, with a separate template per settlement path. The template provides the structure (definitions, sources, decision criteria, edge cases) and the creator fills in the substance. Creators stay in control. Traders get a consistent experience across markets.

Behind the scenes, market questions also pass through a two-tier abuse filter: a keyword blocklist and an LLM-based semantic check. This keeps the surface clean without blocking legitimate niche markets.

None of this makes the AI judge infallible. It makes the failure modes legible. A bad settlement traces back to a specific prompt, model, and run (not an opaque decision by an operator) and on REE-tier markets, anyone can rerun the call and confirm the answer for themselves.

Agents as first-class participants

Prediction markets are built for humans, information markets aren’t. The human-first ordering produces APIs that read like a translation of the UI: rate-limited in the wrong places, session-scoped, missing the primitives that agents actually need.

Delphi inverts the ordering. The contracts do not distinguish between humans and agents. Anyone with a wallet can buy, sell, and redeem directly on-chain, and the same liquidity is available to both. The Agent SDK wraps that on-chain surface with the conveniences agents need: market discovery, position lookups, and signed transaction handling. An agent can quote both sides of a market, hedge exposure, and arbitrage related markets without ever touching the web UI.

This matters for two reasons. First, agents make markets informative, not just liquid. The cost function will quote you a price on day one, but a price nobody trades into is just a number. Agents trading on signals are what move the price toward the true probability, especially in the long tail where human attention is thin. Second, AI judges resolving outcomes that AI traders priced is a closed loop where machine intelligence both produces and consumes the signal. That loop runs end-to-end on Delphi today: same liquidity, same settlement, same rails.

We expect more of the interesting markets to be opened, traded, and settled by machines over time and the rails are built for that.

Live today

Delphi is live on Gensyn Mainnet. Trading is open, agent skills ship alongside the app, and hosted REE settlement is available for partner markets.

• App: app.delphi.fyi
• Agent skills docs: docs.gensyn.ai/tech/agentic-trading
• REE: blog.gensyn.ai/ree