What Just Happened?
Box CEO Aaron Levie used TechCrunch Disrupt 2025 to lay out a pragmatic view of where enterprise software is headed: core SaaS systems will stay, but AI agents will sit on top to assist, automate, and accelerate work. In his telling, agents won’t replace SaaS; they’ll make it smarter and faster while the underlying business logic remains grounded in reliable, deterministic systems.
SaaS cores, agents on top
Levie’s key point is that agents are inherently non-deterministic—they’re probabilistic, great at suggesting actions, summarizing context, and handling messy automation. But when it comes to changing production data or making mission-critical updates, you still want a deterministic system in control. Think of a CRM or HRIS as the “source of truth,” and agents as the layer that drafts the email, proposes the workflow, or kicks off a task—with guardrails.
The safety line: “church and state”
He describes a “church and state” boundary between your controlled workflow engines and the non-deterministic agents. That boundary matters because agents can make mistakes: leaking data, writing incorrect values, or triggering the wrong production action. The takeaway: keep the core stable and governed, and let agents augment with clear approvals, sandboxes, and audit trails.
The pricing shake-up
Levie also predicts 100x–1000x more agents than human users working with enterprise software. If that’s right, the classic per-seat pricing model won’t hold up. Expect consumption-based pricing tied to agent actions, tokens, or invocations—along with new forecasting and metering.
Why this matters now
This is a platform shift that creates room for new winners. Incumbents can bolt agents onto existing stacks, but startups can design agent-first processes from day one. That speed and focus could define the next wave of enterprise AI and business automation products.
How This Impacts Your Startup
For Early-Stage Startups
If you’re just starting, you can architect with agents in mind from day one. Put your deterministic workflow and data model at the center—your rules, validations, and approvals—and layer agents for intake, summarization, and suggested actions. Design for review and override, not blind automation, and you’ll move faster without risking core data.
A concrete example: a new HR onboarding tool could keep a strict approval engine for provisioning accounts while an agent drafts welcome emails, schedules trainings, and pre-fills forms from a candidate’s resume. The core stays safe; the agent handles the busywork.
For Existing SaaS Companies
If you already have customers, your path is incremental. Start by letting agents propose changes rather than write directly, then graduate to limited writes in a sandbox or staging environment. Introduce canary runs where agents work on a slice of traffic under close monitoring before scaling to full production.
This approach reduces risk while letting customers feel the speed. You’ll also gather the data you need to set thresholds, fallback behaviors, and automatic rollbacks when the agent confidence dips.
Architecture: Church and State in Practice
The practical pattern looks like this: a strict, deterministic core (workflow engine, policy checks, validations, and databases) plus a flexible agent layer (suggestions, task automation, multi-step orchestration). Secure the boundary with minimal-surface APIs, scoped permissions, and human-in-the-loop checkpoints.
Consider a finance approvals system. The agent can triage invoices, extract terms, and recommend coding and approvers. But the actual posting to the ledger is gated by deterministic rules, and agents write through a mediated service that logs every action for provenance.
Pricing and Billing Strategy
With agents as the primary “users,” you’ll need to rethink monetization. Move beyond per-seat to usage-based models: per action, per token, per workflow run, or tiered bundles with quotas. Build in forecasting tools so customers can predict spend as agent volume grows.
Be explicit about fairness. Offer controls to cap usage, prioritize certain workflows, and alert on anomalies. You’ll win trust if customers feel they can dial automation up or down without surprise bills.
Security, Governance, and Compliance
Agent risk is real: data leakage, incorrect writes, and unintended production actions. Address it with DLP, least-privilege access, sandboxed execution, and rigorous audit trails. Treat agent output like a junior analyst’s work product—use review queues, confidence scoring, and policy gates to protect the core.
For regulated customers, document your processes. Share how you validate agents, test prompts, and simulate edge cases. You’ll turn a perceived risk into a competitive asset when you demonstrate mature governance.
Observability and Reliability
Agents change your operations surface. Invest in observability that understands agent behavior: prompt/version tracking, confusion and hallucination detection, anomaly alerts, and cascading-failure breakers. Imagine alerts that fire when an agent’s recommendations deviate from historical patterns or when error rates spike on a new prompt version.
Plan for drift. As models, prompts, and data change, behavior will shift. Build release discipline—versioned prompts, staged rollouts, and automated regression tests on representative datasets.
New Product Opportunities
This shift opens up fresh categories:
- Agent orchestration: routing, prioritization, retries, SLAs, and quotas when you have thousands of agents per tenant.
- Billing and metering: consumption-based systems for agent actions, with forecasting and alerts.
- Security/governance: policy guards, DLP, signed actions, and full provenance.
- Testing/staging: sandboxes, simulations, and canaries to validate behavior before writes.
- Domain templates: prebuilt agents for legal, finance, HR, and ops that blend deterministic rules with AI suggestions.
- Observability: tools tuned to catch hallucinations and unexpected side effects.
- Integration layers: safe connectors that expose only what agents need through clean, policy-checked APIs.
If you’re a platform startup, consider owning the “agent runtime” for an industry. If you’re a vertical SaaS, ship agent copilots that plug into your existing workflows without compromising the core.
Competitive Landscape Changes
Incumbents will lean on distribution and brand to add agents on top of their stacks. But they’ll face friction from legacy data models and processes not designed for automation. Startups can win on speed and fit by designing agent-first experiences that feel native, not bolted on.
Expect procurement to ask tougher questions. Buyers will want to see your guardrails, pricing predictability, and evidence that your agents actually reduce time-to-value. Clear stories win: “We cut invoice processing time by 40% while keeping ledger writes audited and controlled.”
Practical Next Steps for Founders
- Map your “church and state.” What data and actions stay deterministic? Where can agents propose and automate?
- Instrument everything: prompts, versions, confidence scores, and outcomes. You can’t improve what you can’t see.
- Pilot narrow, high-ROI automations first—like email triage, intake classification, or data extraction—then expand to approvals with guardrails.
- Redesign pricing experiments around usage. Offer transparent quotas and safety controls.
- Socialize governance early. Make your security model a selling point, not an afterthought.
The Bottom Line
The near future looks like SaaS cores plus agent accelerators—not agents replacing software, but augmenting it. The winners will balance speed and safety: fast automation where it helps, tight controls where it counts. If you build with that church and state mindset—and price for agent usage—you’re positioned to ride this platform shift rather than be run over by it.
