AX Fundamentals: Intro to Agent Experience (AX) Design

As software teams transition from building traditional visual applications to engineering generative AI agents, the fundamental discipline of interface design remains constant. It shifts our focus from building User Interfaces to Agent Interfaces.

For two decades, web applications have centered on User Experience (UX). We designed visual workflows, navigation hierarchies, and input forms to reduce cognitive friction for humans. Today, AI Agents interact with systems using text and structured JSON payloads rather than monitors and mice. This operational reality requires an equivalent discipline: Agent Experience (AX).

Why AX Matters: Interface Design for Inference Engines

In traditional UX, dropping a human into a cluttered, unlabeled screen causes cognitive friction and input errors. In an AI agent runtime, a cluttered context window or an ambiguously named set of tools triggers the exact same failure mode: parameter hallucinations, tool-selection errors, and wasted tokens.

When an agent misclassifies intent or calls the wrong API, the root cause usually traces back to poor interface design within the context window. Treating Agent Experience as a core engineering discipline ensures our generative systems remain:

• Accurate: Clear tool boundaries and typed schemas eliminate parameter hallucinations and tool-routing errors.
• Predictable: Hard operational constraints keep the runtime inside bounded enterprise guardrails.
• Cost-Efficient: Progressive context loading keeps the token payload small, fast, and focused.
• Composable: Modular context files and standardized tool servers can be shared and remixed across different workflows.

Context as an Interface: Concepts vs. Prose

Large language models evaluate semantic proximity across high-dimensional vector space, calculating probabilistic token predictions across an active attention field.

When we feed verbose, conversational prose into a prompt, the model distributes attention weight across unnecessary filler. When we replace narrative paragraphs with structured Markdown headers, condition-first rules, and typed JSON schemas, we concentrate attention weight directly onto our system constraints. Prompt design is information architecture: we assemble dense semantic concepts for an inference engine rather than linear prose for a human reader.

The 3-Tier AX Triad

Production agent architectures reject monolithic prompts. Instead, we structure an agent runtime the same way we structure a modern web application - separating global governance, page copy, and interactive form controls into three distinct architectural tiers.

┌─────────────────────────────────────────────────────────────┐
│                 1. THE OPERATING CHARTER                    │  ├── system_instruction.md
│   (System Instructions: Global Invariants, Mandate, Tone,   │
│                 Authority Limits, Guardrails)               │
└──────────────────────────────┬──────────────────────────────┘
                               │ governs & restricts
┌──────────────────────────────▼──────────────────────────────┐
│            2. MODULAR RUNTIME PROTOCOLS (SKILLS)            │  ├── /skills/
│   (On-Demand SOPs: Step-by-step logic, schemas, heuristics, │  │   └── procurement/SKILL.md
│            task-specific domain documentation)              │
└──────────────────────────────┬──────────────────────────────┘
                               │ executes actions via
┌──────────────────────────────▼──────────────────────────────┐
│           3. INTEGRATION SURFACES (TOOLS & MCPS)            │  └── /mcp-servers/
│       (Deterministic APIs, Database Hooks, Tool Calls,      │      └── inventory-server.ts
│                Permissioned Side-Effect Runtimes)           │
└─────────────────────────────────────────────────────────────┘

1. The Operating Charter (System Instructions)

The Operating Charter establishes the persistent governance floor of the runtime. Just as an enterprise charter establishes a division's core mandate, authority limits, and escalation triggers before work begins, system instructions establish global identity and hard guardrails before any skill is mounted or any tool is called.

2. Modular Runtime Protocols (SKILL.md as Interface Page Copy)

Giving an agent a server full of tools without context is like rendering an application full of unlabeled buttons and empty input fields. To bridge the gap between having a capability and knowing how to apply it, we use modular context Markdown documents (such as SKILL.md files). In AX, these documents act as interface page copy and operational playbooks that load dynamically on demand.

3. Integration Surfaces (MCP Servers & Tools as Action Buttons)

Integration surfaces connect probabilistic model outputs to deterministic software execution. Using the Model Context Protocol (MCP), we group related capabilities into discrete domain servers (application views) that expose atomic tools (buttons and forms) backed by strict parameter validation.

Auxiliary AX Concepts

Beyond the core three-tier stack, several auxiliary patterns help optimize scale, cost, and reliability in production:

• Progressive Context Routing: Loading dozens of tools and manuals into an agent's context window upfront degrades accuracy and wastes tokens. By treating the orchestration harness as a page router - or delegating isolated tasks to sub-agents - we mount and unmount capabilities dynamically based on active state.

• Prefer Concrete (Code First, Model Second): Reserve model tokens strictly for semantic reasoning and unstructured extraction, and offload math, document assembly, and state validation to deterministic zero-token code.

• AX Observability: Just as we refine human user interfaces through session analytics and usability testing, we refine AX by inspecting execution traces, auditing tool-call accuracy, and tightening schemas over time.

The AX Engineering Hub

This article serves as the foundational anchor for the Agent Experience series. Explore the dedicated guides below to dive into each layer of the architecture:

The Core AX Framework

Auxiliary Deep-Dive Track