Your file format just became your liability.
Wherever there’s an incumbent format or application that treats closedness as its moat, I’m watching AI agents route around it with open alternatives. The pattern is straightforward: agents prefer formats they can read and write without proprietary APIs, authentication gates, or vendor lock-in.
The Shift from Apps to Open Formats
This is the natural extension of what I wrote about in From Apps to Agents. The execution barrier collapsed when solo developers with Claude could build in days what took teams months. Now the integration barrier is collapsing too.
Agents don’t care about your licensing model. They don’t respect your API rate limits. They won’t pay for your premium tier. If your format is closed, they’ll simply replicate the functionality using open standards.
Examples I’m Seeing
Here’s the pattern emerging across different domains:
Document Formats
The nuance: Technically, formats like .docx (Office Open XML) are open standards. But agents still prefer Markdown and plain text—not because of licensing, but because of fidelity vs. complexity trade-offs. If the goal is communication (not pixel-perfect formatting), agents route around heavyweight formats. Why parse XML when Markdown gets the job done? And when precision matters, agents can generate webpages or PDFs directly instead of wrestling with intermediate formats.
Data Interchange
Closed incumbent: Proprietary spreadsheet formats, database exports
Agent preference: CSV, JSON, SQLite
Why agents win: Universal parsing, no authentication, transparent structure
Configuration and Settings
Closed incumbent: Binary config files, registry entries
Agent preference: YAML, TOML, JSON5
Why agents win: Human-readable, diff-able, composable
Application Ecosystems
Closed incumbent: Walled-garden app platforms
Agent preference: Open protocols (RSS, ActivityPub, WebDAV)
Why agents win: Interoperability without permission
CSS Frameworks
The Tailwind case: Tailwind CSS hit 75M downloads/month—not because it was necessarily “the best” framework, but because AI coding agents adopted it en masse. The framework’s utility-first approach and plain-text configuration made it trivially easy for agents to generate and manipulate. Agents chose Tailwind, and developers using agents followed.
This is selection pressure in action: the format that’s easiest for agents to use wins adoption, regardless of whether it’s objectively superior by traditional metrics. And as I detailed in How AI Agents Break Traditional Monetization, Tailwind’s agent-driven adoption came with an unexpected cost—40% traffic drop and 80% revenue loss when agents bypassed their documentation monetization.
Why This Connects to Business Moats
In my post on AI Disruption of Business Moats, I outlined how execution difficulty as a moat is evaporating. Companies built moats around implementation complexity (AI commoditized this), integration barriers (agents are commoditizing this now), and distribution networks (as the Tailwind case shows).
Closed formats were part of the integration moat. If your data was locked in a proprietary format, users were sticky. The switching cost was your business model.
That moat just became a liability.
The Cannibalization Pattern
This continues the pattern I’ve been tracking: apps cannibalized by agents (From Apps to Agents), monetization models disrupted (Tailwind’s 80% revenue loss), and now closed formats bypassed. Each step removes a layer of vendor control.
Sell Reasoning, Not File Formats
The old model: Build an app, lock users with proprietary formats, license the software. The new reality: It’s very hard to build a business on an app, and even harder on a file format.
The winning move? Sell reasoning, not file formats. In the past, you made money with app licensing and format lock-in. In the agent era, you sell an agent that’s best-in-class for a specific domain, accessible through a paid API key.
Make your format agent-accessible:
- Plain text over binary whenever possible
- Well-documented schemas that agents can reason about
- Balance security with accessibility - Authentication for sensitive operations, but public schemas where appropriate
- Agent-native interfaces - MCP servers, skill files, or discoverable APIs that agents use autonomously, not proprietary SDKs requiring human integration
The goal isn’t “everything open and free”—it’s making your format accessible enough that agents choose to work with it rather than route around it. Openness becomes the moat when the alternative is being cut out of the agent ecosystem entirely.
What Moats Survive?
Structural barriers I identified in the business moats post still apply: regulatory compliance (agents can’t sign off on tax returns), physical scarcity (agents can’t manufacture chips), proprietary data (unique datasets remain valuable), and insurance-backed guarantees (“we’ll pay if we’re wrong” requires underwriting expertise).
But “our file format is closed” is no longer a moat. It’s a target for agent-driven disruption.
Historical Pattern, Accelerated
Closed formats have always eventually lost to open alternatives when ecosystems grow large enough. The printing press favored reproducible formats. The internet favored open protocols. Agents are accelerating this pattern by an order of magnitude—they won’t wait for your vendor to implement an API endpoint.
Where Value Concentrates
If you’re building software products or file formats:
- Audit integration barriers - Which add value (security, compliance) vs create friction?
- Design for agents first - How easily can an AI agent use your format autonomously?
- Find structural moats - If format closedness is your only moat, you don’t have one
Value migrates to:
- Proprietary data and models - Unique datasets, trained models, domain expertise
- Service and guarantees - Insurance-backed outputs, SLA guarantees, regulatory compliance
- Ecosystem position - Being the default agents reach for (like Tailwind for CSS)
- Workflow integration - Multi-step orchestration, not just format access
- Trust and brand - When agents recommend to humans, reputation matters
The shift isn’t “everything becomes free.” Format lock-in stops being defensible. Companies that built moats around closed formats need structural advantages agents can’t commoditize.
The Uncomfortable Question
What formats are you seeing agents prefer in your domain? Where are closed incumbents most vulnerable?
This isn’t a hypothetical future scenario. It’s happening now, across every industry where agents are being deployed. The question is whether you’re adapting to agent-friendly formats or defending moats that are already dissolving.
Related posts: