Yaniv Golan is Managing Partner at lool Ventures.
Nearly every leadership team now presents impressive “AI agent platform” slides, but they rarely answer the critical question for CFOs and boards: Is this a scalable asset, or a permanent tax on tokens and cognitive solvency?
As an investor working with AI-native startups and who helps more mature, regulated companies think through agents, I see the same pattern from opposite directions. Early teams let agents run almost everything and later discover they cannot really explain or audit critical behavior. Large organizations design a deterministic core and then use agents so cautiously that they capture only a fraction of the upside. The right default is not the same for both.
Two Strategies, Two Defaults
At a high level there are two credible strategies.
Agent-first means you put AI directly in the hot path: agents plan, call tools and make decisions at runtime for most of the product surface.
Critical-core-first means you decide that a small set of invariants—money movement, identity, core data integrity, safety and regulatory rules—live in deterministic, testable code and policies that humans own. Agents are still used at build time and around the edges, but they are not the primary brain where a single mistake can kill the business.
For most early-stage startups, the rational default is agent-first. Your main risk is failing to find product-market fit before you run out of capital, not a regulator knocking on your door. Deterministic code behaves like capital expenditure: You invest engineer-months hardening logic that will probably change. Runtime agentic reasoning behaves like operating expenditure: You pay tokens and some verification cost to put capabilities in front of customers this week and learn faster than competitors.
The structural difference does not change. Deterministic code is mostly CapEx-like (pay up front, then amortize), while runtime agentic reasoning is OpEx-like (pay with every request, forever).
The fastest teams put agents in the hot path for almost everything that is not existential. Pricing experiments, workflow variations, customer-specific logic and internal operations are handled by agents with logging and rollback. The exceptions are the areas that can destroy the company in a single incident: money flows, authentication and clearly illegal or high-harm content. Those sit behind thin deterministic envelopes that agents can call, but not rewrite.
In practice, founders treat agent-first as a loan against future complexity: They accept more dynamic, opaque behavior now with the intention of crystallizing a clearer core later.
The Point Where The Default Flips
The agent-first approach is unsustainable long-term. As the business scales, the increased traffic, revenue and regulatory exposure naturally raise the economic and risk profiles, driven by potential existential errors, enterprise audit demands and system complexity that defies understanding.
At that point, your world starts to look much closer to a traditional enterprise. Some invariants are slow-moving and brutally expensive to break. Those belong in deterministic code and declarative policies, with clear interfaces that agents must respect. For banks, insurers, healthcare providers and later-stage SaaS platforms with large ledgers and regulators in the loop, a critical-core-first stance is usually the only sustainable posture: a small, boring, auditable core surrounded by an agentic surface.
Cognitive Solvency: The Real Cost After Tokens Hit Zero
Even if tokens dropped to zero tomorrow, fully agentic systems still wouldn’t be free. The real constraint most teams hit first is cognitive solvency, or the ability of your senior people to still understand what the system is doing well enough to approve changes and handle incidents.
A strong agent can generate more PRs in a week than your team used to ship in a month and can assemble novel tool chains in production. Reviewing that output is brutally expensive—sometimes even harder than writing from scratch. You end up with senior engineers reduced to human compilers, busy with endless review queues, and most likely rubber-stamping. That six-figure verification tax sits right next to your LLM bill, even if the board never sees the invoice.
A Simple Checklist Before You Put An Agent In The Hot Path
For any meaningful workflow, a short checklist helps:
1. What is the cost of being wrong, financially and reputationally, with regulators? High-cost errors default to deterministic code, plus a narrow agentic layer.
2. How often does the logic really change? Weekly or daily changes are candidates for agentic behavior with strong observability and rollback. Yearly changes are better expressed in code.
3. Can you observe and reverse agent behavior quickly when something drifts? If you cannot, keep it out of the hot path.
4. Does per-request reasoning clearly earn its keep through fewer escalations, better customer experience, materially lower handle time or improved risk outcomes? If the uplift is vague, keep the logic in code and use agents at build time.
Match The Bet To Your Stage
If you are an early-stage AI-native startup, I recommend defaulting to agent-first everywhere except the small set of things that can bankrupt or jail you. Be explicit that you are taking on a loan you will need to repay by hardening a core once the business stabilizes.
If you run a later-stage or regulated company, default to a small deterministic core surrounded by an agentic surface, and demand hard evidence before letting agents into the hot path of money, identity and safety.
In both cases, the lowest-regret move is the same: Keep a clear boundary between critical invariants and the parts of the system where you are willing to pay for per-request cognition. That boundary is what lets you lean into agents when they clearly earn their keep—and pull back when they do not.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
