From Records to Agents: The Overlooked Revolution in Enterprise Software

Enterprise software is terribly unsexy. And yet, it’s where most of the money, complexity, and frankly, innovation in software actually happens.

Lately, everyone’s talking about how AI will replace the need for humans to use and interface with enterprise software. This misses the more profound shift: business objects, the atomic units of enterprise software, are themselves becoming autonomous.

The next wave of enterprise software platforms is less about replacing the humans who use them than giving life to the objects inside them.

The Next Evolution: From Records to Machines

Imagine: the invoice isn’t just a record in your ERP anymore. It’s a machine that wants to get approved. It wants to get paid. The opportunity doesn’t just sit in a database—it actively pursues its own closure.

This isn’t metaphorical. The technical foundations for this shift have been quietly assembling:

The actor model provides isolation and message-passing patterns
Durable execution enables long-running, persistent processes
State machines formalize complex lifecycles
LLMs now offer the intelligence layer that makes it all viable

Consider an invoice in this new paradigm. Instead of being a passive record waiting for humans to process it, it becomes an autonomous agent that:

Understands its own approval requirements
Navigates the org chart to find appropriate approvers
Gathers missing information by itself
Interprets policy to determine exceptions
Coordinates with related systems (payment platforms, accounting systems)
Only pulls humans in when genuinely necessary

But to understand the future, we need to understand the past. The story arc is familiar but worth revisiting.

The Deliberate “Badness” of Enterprise Software

Enterprise software is “bad” for good reasons. Its apparent clumsiness—endless customization options, complex permissions, torturous approval flows—isn’t a failure of design. It’s a reflection of organizational reality.

Companies aren’t simple. Their processes evolved over decades, shaped by regulation, internal politics, acquisitions, and thousand-page policy manuals. Enterprise software must accommodate all this messiness or it fails. This explains why:

Simpler alternatives repeatedly fail to unseat incumbent platforms
Department-level software gradually expands into platform-level complexity
“Digital transformation” projects that ignore existing complexity implode spectacularly

The best enterprise software doesn’t fight this complexity—it embraces it, making it configurable rather than hardcoded.

Enterprise 1.0: The Database Era

Enterprise software 1.0 was fundamentally about databases and records. Oracle didn’t become a behemoth by accident—organizing information into relational models changed everything. The core architecture was simple: databases storing records, surrounded by business logic to enforce rules, wrapped in UIs that let humans manipulate those records.

SAP, PeopleSoft, Siebel—behind their Byzantine interfaces and complex workflows, they were all essentially specialized views into databases, organized around concepts like accounts, orders, invoices, and employees.

Enterprise 2.0: The Cloud Transition

The cloud changed where enterprise software lived, but not what it was. Salesforce’s genius wasn’t technical—it was business model innovation. Same database of accounts and opportunities, same workflows, same reports—just delivered through a browser with a subscription model.

Workday, ServiceNow, NetSuite—these platforms succeeded by taking the fundamental database-and-workflow model and making it more accessible, configurable, and connected. But they’re still, at their core, databases with workflows.

Enterprise 3.0: IBM All Over Again

The transition from passive records to autonomous objects (or: Intelligent Business Machines) fundamentally changes how we think about enterprise software:

Architecture: From CRUD operations to message-passing, from central databases to distributed actors
Human-computer interaction: From form-filling to intent expression, from workflow execution to exception handling
Implementation: From procedures to protocols, from status fields to state machines
System boundaries: Previously separate systems now have objects that collaborate directly

The critical insight: The AI isn’t replacing the human users. It’s bringing the data objects themselves to life.

Where This Takes Us

This isn’t just architectural evolution—it reshapes the enterprise:

Process complexity becomes encapsulated within intelligent objects rather than externalized in workflows
Cross-system processes happen through direct collaboration between autonomous objects
Business rules transform from explicit if-then statements to emergent behaviors
Humans shift from process operators to goal-setters and exception-handlers

If Enterprise 1.0 was about recording business activity, and 2.0 was about connecting it, Enterprise 3.0 is about animating it.

The spreadsheet that runs your department doesn’t just track things—it actively optimizes them. The CRM record doesn’t just store contact details—it builds the relationship.

Every object becomes a capable, goal-directed agent in a business ecosystem.

The Technical Reality

For the technically inclined, this isn’t science fiction—it’s the confluence of several mature patterns:


Actors + Durable Execution + State Machines + LLMs = Autonomous Business Objects

Underlying infrastructure advances like durable workflow execution and stateful actor models already provide much of the infrastructure. The LLM revolution supplies the missing intelligence layer.

Cloudflare’s Durable Objects and Workers are particularly interesting here—they provide precisely the kind of globally distributed, low-latency runtime that autonomous business objects need. When your invoice needs to coordinate with systems across continents, edge computing isn’t just nice-to-have, it’s essential infrastructure.

Companies building in this direction aren’t creating “AI assistants”—they’re creating autonomous business objects that understand their purpose and pursue it relentlessly.

The Data Gravity Shift

This architectural revolution is happening alongside another seismic shift: the emergence of the data cloud. Snowflake, Databricks, and their underlying table formats (Iceberg, Delta) are rewriting how enterprises think about data:

Data is no longer locked inside application silos
Zero-copy data access eliminates expensive, brittle ETL pipelines
Data sharing enables cross-organizational analysis without moving data

The convergence is powerful: autonomous business objects with direct access to vast data lakes, able to analyze patterns across departmental and even organizational boundaries.

Imagine an accounts payable agent at Company A that can:

Access historical payment patterns across the entire vendor ecosystem
Compare current invoices against industry benchmarks
Identify potential fraud by correlating signals across multiple organizations
Negotiate optimal payment timing based on cash flow predictions

This isn’t just more efficient—it creates entirely new capabilities that weren’t possible in siloed data environments.

From Concept to Reality

These aren’t just theoretical musings. Companies at the bleeding edge are already building this future:

CoPlane’s autonomous AP and AR objects are reimagining financial operations, turning static invoices and payments into goal-seeking entities that optimize working capital and keep vendors happy
Koala is transforming prospective accounts from passive database records into active entities that pursue their own conversion with minimal human intervention
Hightouch is turning “campaigns” into autonomous decision engines for reaching and converting new customers and educating and upselling existing ones
Archive is turning UGC that references your brand into assets that can autonomously seek usage rights and amplify and monetize them

What’s particularly interesting is how these systems cross traditional boundaries. When an autonomous invoice negotiates with an autonomous cash management system, we’re witnessing something truly novel: software objects conducting business with each other, each optimizing for their own objectives while finding collaborative solutions.

Final Thoughts

Enterprise software’s evolution isn’t about replacing humans with AI. It’s about transforming static records into autonomous, goal-seeking entities that can navigate across systems, organizations, and data repositories.

When your invoice wants to get paid as much as you want it to be paid, when your sales opportunity is as motivated to close as your sales rep, when your data entities can find and utilize information regardless of organizational boundaries—that’s when enterprise software truly changes.

The future isn’t humans vs. AI. It’s a collaborative ecosystem of human and non-human agents, each with their own goals, capabilities, and responsibilities, connected through shared data and purpose.

The records are waking up. Business will never be the same.