Beyond HTML: How ANML is Reshaping the Web for AI Agents

The Web Has an Audience Problem

For three decades, HTML solved a fundamental problem: how do you present information to human eyes? Tables, paragraphs, images, forms—all optimized for visual parsing and human decision-making. It's beautiful in its simplicity.

But we're living through a pivotal moment. The primary consumers of web content are no longer exclusively humans. Autonomous agents—AI systems that interpret data, make decisions, and execute actions—are becoming the dominant force interacting with our digital services. And here's the uncomfortable truth: HTML is terrible for them.

When an AI agent encounters a typical HTML page, it's forced to:

• Parse visual semantics that have no structural meaning
• Infer what information matters through probabilistic guessing
• Figure out workflows by reverse-engineering form structures
• Make assumptions about privacy, consent, and authorization

Every inference is a cost. Every assumption is a potential failure point.

Enter ANML—Agentic Notation Markup Language.

The Duck Analogy That Actually Works

The ANML Foundation uses a deceptively elegant metaphor: imagine a duck gliding across water. On the surface, it's graceful and simple. Beneath the waterline? Complex, coordinated systems working in perfect harmony.

That's what an ANML document (called a "duckument"—yes, really) achieves. To a human reading it, it appears straightforward and readable. But underneath, it contains everything an autonomous agent needs:

• Explicit service capabilities instead of inferred workflows
• Machine-readable constraints instead of hoped-for compliance
• Structured knowledge exchange instead of unstructured data
• Clear privacy boundaries instead of policy documents agents ignore

The brilliance is that ANML doesn't abandon human readability. It augments it.

Machine-First Architecture Meets Real-World Needs

Traditional APIs force agents into uncomfortable positions. They must:

Minimize inference. Every decision an AI agent has to make through probabilistic reasoning is energy, latency, and potential error. ANML eliminates this by making intent explicit. A concert ticket service doesn't require agents to figure out that there's an early-bird discount—it explicitly declares it with timing, constraints, and conditions.

Maximize determinism. When an agent interacts with your service, you want predictable behavior, not probabilistic interpretation. ANML's structured format means agents execute your intended workflow, not their best guess at what you probably meant.

Respect boundaries. The most overlooked aspect of agentic web development: agents need permission frameworks. ANML bakes privacy by design directly into the markup, with disclosure constraints that agents must evaluate and respect. Users maintain control over what information their agents can share and with whom.

The Dual Serialization Advantage

Here's something elegant: ANML isn't language-specific or format-specific. It normalizes both XML and JSON.

XML for humans who need to read and author the document directly. It's verbose, yes, but its structure is self-documenting. A developer reviewing your service's agent interface can actually understand what it's saying.

JSON for programmatic generation and agent-pipeline consumption. Your backend generates it, agents consume it, CI/CD pipelines validate it. No translation layer required—both formats are equally authoritative.

This dual approach respects the reality of how modern systems actually work, rather than forcing a false binary between human-readable and machine-optimized.

What Lives Inside an ANML Duckument

Think of an ANML document as a comprehensive interface specification for autonomous agents. It defines five critical things:

** Structured, semantic information that doesn't require inference. Not "click here to buy a ticket," but explicit declarations of pricing, availability, terms, and conditions.

Interactions: Operations with clear binding to HTTP methods, endpoints, and required parameters. Your agent knows exactly how to perform each action without guessing.

Knowledge: Bidirectional information exchange. The service declares what it knows and what it needs to know from the agent's user. Questions are explicit, not buried in form labels.

Constraints: The rules agents must follow. Disclosure limitations, consent requirements, authorization gates. These aren't suggestions—they're machine-evaluable conditions.

State: Metadata identifying where you are in a multi-step workflow. Agents understand whether they're at step 1 of 3, what decisions they made, and what comes next.

Persona: Behavioral and tonal guidance for how agents should represent themselves and your service to users. It's not mandatory instruction, but advisory guidance that helps maintain brand voice and appropriate interaction patterns.

Why This Matters for Your Stack

If you're building services that autonomous agents will interact with—and statistically, you will be soon—ANML represents a fundamental upgrade to how you think about APIs and integrations.

Current reality check: Most services aren't designed for agents at all. They're designed for human developers to build custom integrations. When AI agents interact with them, they're doing their best to pattern-match and infer. It's like watching someone try to use a smartphone designed for hands while wearing mittens. It works, sometimes, but it's not optimal.

ANML is the alternative. It's saying: "Let's design services that agents understand natively, with all the explicit structure, boundary-setting, and workflow clarity that machines actually need."

For developers, this means:

• Better agent reliability when external agents interact with your services
• Clearer API specifications that both humans and machines can trust
• Privacy guarantees you can actually enforce
• Reduced inference overhead for AI systems working with your data

The Bigger Picture

We're witnessing the emergence of what you might call the "agentic web"—a parallel layer of the internet optimized for autonomous systems in the same way the current web is optimized for humans.

HTML didn't go anywhere when interactive JavaScript frameworks emerged. It evolved. HTTP didn't disappear when REST APIs became dominant—they coexist. ANML isn't replacing HTML. It's a new layer of abstraction, designed specifically for the architectural pattern that's becoming increasingly central to how systems interact: autonomous agents acting on behalf of users.

The question isn't whether to adopt ANML today. It's whether you'll be ready when agents become the primary way services consume your data, make transactions, and execute workflows on your platform.

The duck is gliding across your surface. Make sure you understand what's happening beneath the waterline.

Getting Started

If this resonates with your development philosophy—particularly if you're thinking about agent-first architecture, API design, or building services that play nicely with autonomous systems—now's the time to explore the ANML Foundation's specification.

The shift from human-first to agent-capable architecture is just beginning. Being an early adopter puts you ahead of the curve, especially if you're in fintech, e-commerce, SaaS platforms, or any domain where multi-step workflows and privacy-respecting automation matter.

The future of web APIs isn't just about REST endpoints and documentation. It's about explicit, machine-executable instructions that respect both user autonomy and service boundaries.

Duckuments are coming. Will yours be ready?