AI Agents Don't Kill Document Processing. They Make It Inevitable.
Why agents depend on structured document intelligence — not replace it.
I built a few entire slide decks using Lovable + Claude Code.
No Google Slides.
No manual layout nudging.
No “move this box 2px to the left”.
Just intent → iteration → refinement.
Not because slides are hard.
But because slides are a perfect proxy for a much bigger shift that’s happening.
1. What I was actually testing
This wasn’t about “AI makes slides faster”.
I wanted to experience, end-to-end, what it feels like when:
- reasoning is delegated
- structure emerges through dialogue
- iteration is cheap
- and execution happens at the speed of thought
In other words: agents as collaborators, not tools.
Lovable handled layout and visuals.
Claude Code handled logic, structure, narrative consistency.
I stayed in the loop, but I wasn’t the bottleneck.
The most interesting part wasn’t the final deck.
It was the feedback loop:
- propose → inspect → adjust → regenerate
- zoom out to narrative, zoom in to details
- move from “what should this say?” to “what’s the best representation of this idea?”
This felt much closer to designing a system than writing slides.
And that’s the key point.
2. Agents don’t kill document work — they depend on it
There’s a narrative I keep hearing:
“With agents and LLMs, documents won’t matter anymore.”
I think that’s fundamentally wrong.
Agents don’t operate in raw text chaos.
They operate on representations.
Slides, PDFs, contracts, reports, invoices, emails. These are not dead artifacts.
They are how humans:
- record decisions
- encode intent
- communicate constraints
- leave evidence behind
Documents are not the problem.
Unstructured documents are.
Agents don’t want “a PDF”.
They want:
- entities
- relations
- tables
- confidence
- provenance
They want something they can:
- reason over
- verify
- transform
- pass to another agent
Without document intelligence, agents are:
- brittle
- unverifiable
- hallucination-prone
- impossible to audit
With it, they become:
- reliable
- composable
- enterprise-ready
This is not competition.
This is stack alignment.
3. Why this matters deeply for what we’re building at anyformat
At anyformat, we’ve always thought about documents differently.
Not as files.
Not as OCR problems.
But as interfaces between humans and machines.
When enterprises say:
- “We have thousands of PDFs”
- “We have emails and scans”
- “We have legacy reports”
What they really mean is:
“Our most important knowledge is locked in formats machines can’t reliably reason about.”
Agents don’t change that reality.
They expose it.
The more autonomous systems become, the more critical it is that:
- inputs are structured
- outputs are traceable
- decisions can be explained
Document intelligence becomes the substrate layer (and MCP is how agents will access it):
- turn messy inputs into structured tables
- attach confidence and provenance
- feed deterministic workflows
- enable agents to act safely
The irony is that as AI feels more “magical”, the infrastructure underneath needs to become more boring, more rigorous, more deterministic.
That’s where real value compounds.
4. What building slides with agents taught me (unexpectedly)
Using Lovable + Claude surfaced a few patterns that feel universal:
1. Speed changes taste
When iteration is cheap, you aim higher.
You discard mediocre ideas faster.
2. Structure > content
Once the narrative spine is right, filling details becomes trivial.
3. The human role shifts upward
I wasn’t choosing fonts.
I was choosing:
- what matters
- what’s redundant
- what story is being told
This is exactly what we see with document workflows:
- extraction alone isn’t enough
- structure enables judgment
- judgment enables automation
Agents don’t remove humans.
They force humans to operate at a higher level of abstraction.
5. The real framing (and why I’m bullish)
The future is not:
“Agents replace document processing”
It’s:
Agents massively increase the value of document intelligence
Because every agent:
- needs clean inputs
- needs verifiable facts
- needs structured context
- needs a memory it can trust
Documents are still where the world runs.
AI just finally gives us a reason to take them seriously as systems, not files.
This is why I’m excited.
This is why we’re building.
And this is why experiments like “AI-generated slides” matter far beyond slides.
They’re signals of where the stack is converging.
We’re still early.
The tools are rough.
The abstractions are forming.
But one thing feels clear:
AI agents won’t make document intelligence obsolete. They’ll make it unavoidable.