What the new application layer looks like

Over the past year, I’ve been writing and thinking a lot about autonomous systems and AI agents — not as a buzzword, but as a fundamentally different way software operates. What started as a curiosity (“what happens when software can actually do the work?”) has become a steady stream of founders showing me radically reimagined versions of SaaS.

Not incremental AI features.
Not a chatbot bolted onto an old product.
But new application-layer user experiences built from first principles.

Satya Nadella captured the shift perfectly:

“Business applications … are essentially CRUD databases with a bunch of business logic. In the agent era, all of that collapses."

AI forces us to see SaaS for what it fundamentally is — a set of primitives that are suddenly up for reinvention. The most interesting AI-native products I’m seeing aren’t adding intelligence around those existing SaaS primitives. They’re eliminating the need for most of that UI/UX entirely.

After seeing this pattern over and over, I wanted to get more precise:

• What is actually changing in the application layer?
• What are the new primitives in an agentic world?
• And how do we evaluate whether a product is truly AI-native versus simply stapling models onto old architectures?

This post is my attempt to answer those questions — to map the shift from traditional SaaS (workflow builders, forms, rules, approvals, dashboards) to systems where agents plan, execute, optimize, and explain work, with humans only in the loop for the parts that truly require judgment.

1. Workflow Builders → Dynamic Agentic Workflows & Best-Practice Executors

Old primitive:

SaaS relied on users to design and advance workflows:

• pipelines
• Kanban boards
• onboarding wizards
• CRM stages
• campaign builders
• brittle if/then automations

Software couldn’t decide the optimal sequence, so humans manually encoded it.

New primitive:

AI-native applications fall somewhere in a spectrum between two UX models - one where the workflow disappears entirely, and one where the workflow stays visible but the setup goes away.

A. Agentic Workflows - the workflow goes away entirely

Agents take a goal and execute the multi-step workflow automatically—no stages, no builders, no “pushing tasks forward.” You give intent; the system handles the sequence.

• “Resurface all stalled deals, generate next actions, and take those actions.”
• “Rebuild the implementation plan for ACME and start the first three steps.”
• “Triage and prioritize this backlog based on urgency and effort.”
• “Refactor this module and open PRs.”
• “Build a churn analysis and draft a narrative.”
• “Launch a retargeting sequence for segment X.”

This removes the need for workflow screens almost entirely.

B. Enforced Best-Practice Workflows (structured UX)

But not everything becomes a chat interface. In many categories, the winning UI will be:

Software that enforces the industry’s best-practice workflows by default — and refuses bad configuration.

This dramatically reduces:

• inconsistent, complex, and poorly documented workflow configuration
• inconsistent execution of process
• training time
• reliance on consultants for their expertise
• constant internal meetings & debates about how work “should” be done

AI gives every team the benefit of a well-designed workflow without months of setup, debate, consultants, and customization.

The net result:

The workflow builder — a defining feature of SaaS for 20 years — becomes either unnecessary (agentic workflows) or radically simplified (best-practice defaults).

Humans no longer design workflows; software does.

Example – Thruline

Thruline’s Blueprints product takes ERP requirements transcripts and auto-generates a configured ERP instance — taking implementations from 90 days → 14 days.

This is agentic workflow generation + embedded best practices.
It shows exactly how workflow builders collapse in the AI era.

2. Data Entry → Automatic Ingestion, Understanding & Updating of Data

Old primitive:

Most SaaS UIs were glorified forms. Humans across functions spend anywhere from 10% - 20% of their day inputting data into those forms.

• fields
• dropdowns
• tagging
• notes
• CSV uploads
• multi-step data entry screens

Humans provided the structure so the system could run.

New primitive:

Agents automatically ingest, interpret, and structure unstructured data from:

• emails
• documents
• invoices
• internal systems
• the open web
• prior user behavior

The UI becomes lightweight:
connect your data → specify your goal → let the agent work.

This is already visible in email and scheduling, which are quickly becoming fully agentic workflows across hundreds of early-stage startups.

Example – Mentium

Mentium monitors operational email streams, reads invoices and manifests, extracts structured data, writes directly into ERPs/TMS systems, and escalates only true exceptions.

Result:
Logistics providers can prevent millions in annual revenue leakage through real-time ingestion and reconciliation — without the large teams of human finance and operations currently required to do this.

With AI, Mentium is able to ensure higher accuracy data on an ongoing and continuous basis, without the need for endless human data entry.

3. Business Logic → Self-Optimizing Policies

Old primitive:

Static business logic lived in brittle, manual artifacts:

• configuration pages
• rule trees
• validation logic
• scoring models
• decision flows

These required months of implementation and constant human upkeep. And because they rarely get updated, rules quickly become outdated, inconsistent, or misaligned with how the business actually runs. The result is logic that drifts away from the original intent and slows down an organization’s ability to improve its processes. Static rules simply couldn’t adapt as the business evolved.

New primitive:

Instead of hand-maintained configuration screens and rule trees, the logic behind decisions updates continuously based on new data, edge cases, and outcomes.

• rules become adaptive
• policy improves with every cycle
• exceptions are learned, not hard-coded

• conflicting rules are detected and corrected automatically
• intent stays aligned because the system can evaluate whether actions match the desired outcome
• explanations stay consistent because the agent summarizes the policy as it evolves

AI doesn’t just execute decisions — it improves the decision logic itself.

This is the shift from rules you maintain → to policies that maintain themselves.

It marks the end of the static, implementation-heavy era and the beginning of software that acts as its own operator.

Example – Stacktalk

Stacktalk continuously aligns:

• regulatory requirements
• internal policies
• operational code paths

Agents detect inconsistencies, non-compliant logic, and revenue leakage — before regulators or auditors do.

It’s policy → code → compliance alignment, automated.

Stacktalk is the strongest example of the self-updating policy layer, where the software itself ensures correctness and compliance.

4. Approvals → Decision Delegation + Human Oversight

Old primitive:

Humans had to authorize a wide range of actions because software couldn’t be trusted to make the judgment.

Approvals spanned every major function:

• managerial sign-off (discounts, exceptions, escalations)
• legal sign-off (contracts, redlines, risky terms)
• compliance sign-off (KYC/AML, policy exceptions, regulated actions)
• finance sign-off (spend approvals, reimbursements, invoice releases)
• procurement sign-off (vendor onboarding, renewals, non-standard purchases)
• operations sign-off (inventory adjustments, fulfillment overrides, workflow rerouting)

These approvals existed not because humans enjoyed gatekeeping, but because the systems:

• couldn’t detect risk
• couldn’t explain decisions
• couldn’t validate correctness
• couldn’t interpret nuance
• couldn’t reconcile conflicting logic
• couldn’t anticipate downstream effects

So workflows paused at every point where judgment was required.

New primitive:

Agents perform the end-to-end work - and escalate only when true human judgment is required.

The new UX becomes:

• “Here’s what I did.”
• “Here’s why.”
• “Here are the cases that need your judgment.”

This is governance, not workflow gating. Compliance and audit trails become richer because every agent action is logged and explainable.

Example – JustPaid

JustPaid’s AI agent automates the full revenue workflow from contract to cash — not just invoice creation, but billing-term extraction, multi-source payment matching, and proactive collections.

What used to require finance teams approving every billing term, verifying invoice accuracy, reconciling payments, and chasing collections is now handled by the agent:

• reading contracts and inferring billing logic
• generating invoices and monitoring payments across bank feeds and PSPs
• identifying discrepancies and escalating only ambiguous cases

The UX shifts from finance teams approving every step to:

• “Routine invoices and reconciliations were handled automatically. Here are the few exceptions that need your review — with context.”

JustPaid demonstrates the new approval primitive: continuous autonomous execution, with humans governing only the ambiguous or high-impact exceptions.

5. Dashboards → Narrative Insights & Recommended Actions

Old primitive:

Dashboards required humans to make sense of the data:

• charts
• filters
• drill-downs
• exports
• scheduled reports

Insights were disconnected from action and required data teams.

New primitive:

Agents automatically interpret results and tell you:

• what changed
• why it changed
• what to do next
• what they’ve done already

Analytics become narrative and actionable — not just visual. Insights are tied directly to execution. AI can also take action on these insights immediately.

Example – Unseen

Unseen ingests messy operational real estate data and produces clear, narrative insights that operators can act on immediately — no data engineering or BI team required.

It demonstrates the complete transition from hard-to-configure dashboards → dynamic best-practice analyses that are immediately actionable by human or Unseen’s army of agents.

These on-the-fly dashboards enabled by AI ‘wow’ prospects - delivering “live-on-the-demo” analytics that compress months of expected data engineering into minutes — proving how AI-native analytics radically accelerate time-to-insight.

The New Application Layer

The primitives of SaaS aren’t disappearing — they’re being rewritten.

For two decades, the application layer was built around predictable surfaces:
workflow builders, data entry, business logic, approvals, and dashboards.
They worked because software couldn’t perform the work itself. It needed humans to design the workflow, provide the data, enforce the rules, make the decisions, and interpret the results.

AI changes that.

Agents don’t wait for configuration or dense UI screens.

They plan work, take actions, update systems, enforce policy, and surface only the cases that need human judgment. Insight isn’t a dashboard anymore; it’s a narrative, tied directly to action.

The shift is simple:

From software that requires human-driven workflows
→ to software that operates on behalf of humans.

The most powerful AI-native products combine several of these new primitives to deliver leverage, speed, and accuracy that weren’t possible in the SaaS era.

Thruline, Mentium, Stacktalk, JustPaid, Unseen — these are just a few early examples of a much larger wave. The new application layer won’t be defined by “AI features,” but by products that rethink the primitives entirely.

This is the architectural shift I’m most excited about — and the one that will define the next decade of enterprise software.

If you’re reimagining next-gen AI UX — or know someone who is — I’d love to talk.
Reach out to me at chris.millisits@antler.co.

At Antler Elevate, we invest in Seed–Series B startups, helping them scale globally across our 20+ country footprint.