Discoverable at Runtime
Endpoints explain what they do, what they expect, and what they can produce at the moment they are being used.
Artificial Intelligence eXecution Endpoints
AIXE turns the web into a place where AI systems are first-class participants, not second-class scrapers.
Artificial Intelligence eXecution Endpoints for a world where humans, software, and autonomous agents can all discover and operate real execution surfaces at runtime.
AIXE defines a runtime contract for discoverable execution surfaces. Websites become intentional for both human use and AI use: endpoints describe what they can do, what they require, and how callers can recover when the live rules change.
This protocol brings together runtime discovery, self-describing endpoints, intent-aware routes, field and error semantics, wrapper-friendly rollout, and a clearer path toward a web where AI systems are met with structure instead of forced to scrape for meaning.
Inventor and protocol driver: Gregory Oglethorpe
First-Class AI Participation
AIXE treats AI-facing contracts as a legitimate part of the website, not an afterthought beneath the human interface.
Designed for Intent
The protocol moves software interaction away from brittle guesswork and toward declared outcomes, context, and execution semantics.
Protocol Overview
AIXE is a protocol for runtime-discoverable capability, not a thin layer of API cosmetics.
Invented and driven by Gregory Oglethorpe, AIXE moves from first principle through runtime discovery, route grammar, field and error contracts, reference flows, rollout strategy, and the wider consequence of a web where execution surfaces explain themselves.
Execution Surfaces
Why AIXE treats endpoints as live capability surfaces instead of passive transport shapes.
Go deeperRuntime Clarity
How AIXE turns runtime interaction into a clearer and more teachable experience.
Go deeperWhy APIs Break Down
A closer look at the structural weaknesses AIXE is trying to solve.
Go deeperFoundation
What Is AIXE
Start with the contract shift itself: AIXE turns endpoints into execution surfaces that can explain themselves while they are being used.
AIXE introduces the protocol's core claim, clarifies why the old interface model breaks down under agentic use, and establishes the language the rest of the standard depends on.
Executive Summary
A fast but serious entry into the protocol's core claim and strategic importance.
Go deeperReading Map
A guide to different paths through the full AIXE paper.
Go deeperFull Whitepaper
Open the full AIXE whitepaper in its dedicated white-background specification presentation.
Read nowCanonical Reference
Whitepaper
The canonical paper remains the authoritative statement of the AIXE protocol invented and driven by Gregory Oglethorpe, with faster entry paths for summary, navigation, and the full specification view.
The executive summary, reading map, and white-background specification create a direct path from orientation to formal protocol detail and make the protocol's origin clear.
Intent Execution
How AIXE makes outcome and business action visible in the public interface.
Go deeperPublic Route Grammar
How route structure can stay human-legible while still supporting richer capability.
Go deeperHidden Internal Linkage
Why the public AIXE contract hides internal graphs and linkage mechanisms.
Go deeperProtocol Mechanics
Protocol Concepts
Move from the broad pitch into the mechanics that give AIXE its operational shape.
AIXE defines intent, route design, and the boundary between public meaning and internal implementation.
aixe.ai Discovery
How the minimal aixe.ai file acts as the first handshake into an AIXE-aware service.
Go deeperEndpoint Self-Description
How AIXE uses live endpoint description to replace brittle guesswork with runtime guidance.
Go deeperField and Error Contracts
Why AIXE gives field semantics and corrective errors an elevated role in the contract.
Go deeperLive Interface Layer
Discovery & Contracts
This is the live teaching layer of AIXE: how software advertises itself, explains itself, and corrects callers without forcing them into guesswork.
Here the protocol becomes inspectable. Discovery files, endpoint descriptions, field semantics, and structured error guidance all converge into the caller experience.
Create Order Reference
The reference interaction that shows how AIXE can clarify a real business operation.
Go deeperContract-Aware Self-Healing
How live contracts make adaptive recovery more plausible when interfaces change.
Go deeperRollout Without Rebuilds
How AIXE can be layered onto existing systems instead of requiring total replacement.
Go deeperPractical Adoption
Reference Flows & Rollout
See how the protocol behaves in a concrete example and how adoption can happen without ripping systems apart.
The order-creation reference, self-healing behavior, and wrapper-based rollout path make AIXE implementable rather than idealistic.
Interoperable AI Across the Web
What AIXE means for a more interoperable and discoverable agent-facing web.
Go deeperCapability Detached From Presentation
Why AIXE matters for systems whose real capability outlives any single UI shell.
Go deeperDurable Multi-System Workflows
How better public contracts make cross-system workflows more durable over time.
Go deeperWhat This Unlocks
Future & Vision
The protocol becomes consequential through the kind of web it helps create.
Runtime-discoverable capability leads toward interoperable agents, software decoupled from UI constraints, and more durable workflows across many systems.
Protocol Consequence
AIXE points toward a more legible web: one where capability can be discovered, interpreted, and used without so much hidden human glue.
The protocol gives humans, software, and autonomous agents a clearer way to discover what a system can do, understand how to use it, and recover when the live contract changes.
Read the Canonical Whitepaper