The most important design decision in enterprise AI this fall isn't which model you use. It's how little you let it decide once the work starts.
In Today’s Email:
Two vendors that rarely agree on anything have landed on the same architectural idea: let the language model reason and plan, then take it out of the loop when it is time to execute. Oracle built Fusion Claw around a frontier model that plans and deterministic enterprise computation that executes. Salesforce built Agent Script around a hybrid reasoning engine that runs business logic as code with no LLM involvement. The reliability problem behind it is no longer theoretical. Research from Thinking Machines Lab found 80 unique completions in 1,000 runs of the same prompt at temperature zero, and half of enterprises in a recent VentureBeat survey reported an agent that passed internal evaluations and still caused a customer-facing failure. Building on "Governance-by-Design" (Mar 5), "The Trust Equation" (Mar 26) and "The Continuous Audit" (Sep 24), this issue explains what the deterministic turn is, how the two approaches differ, and the questions buyers should ask before they sign.
News
1. The OWASP "Non-Human Identity" Warning and the Push for Runtime Governance
The governance crisis surrounding autonomous systems escalated this week as security researchers at OWASP officially flagged unmanaged AI agents as one of the fastest-growing attack surfaces in enterprise environments. Because agents take action rather than just retrieving data, the risk of "blank-check access"; where an agent is granted overly broad permissions simply because it's easier to configure; has skyrocketed. In response to this threat, the market is seeing a rapid emergence of runtime security platforms; for example, Vero launched its AI Runtime Governor this week, designed specifically to monitor live tool invocations and block agents from executing unauthorized or malicious actions in real time.
Key Takeaway: Static access reviews are no longer sufficient. IT and security teams must evolve their policies from merely managing what human employees can see to actively restricting and monitoring what autonomous agents can do at machine speed.
2. Model ML Secures $250M to Give Every Banker a 24/7 Agent
The transition from AI as an "assistant" to AI as a "background worker" hit a massive milestone this week when Model ML secured $250 million in fresh funding. Built specifically for the highly regulated financial sector, the platform aims to provide every banker, consultant, and investor with a personal AI agent that operates 24/7 inside the firm's trusted legacy systems. The company's leadership explicitly noted the shifting expectations of the digital workforce: AI must now move beyond just generating text or answering questions to actually understanding the context of the work, executing it autonomously in the background, and delivering a finished product.
Key Takeaway: The bar for enterprise AI adoption is moving from "brainstorming support" to end-to-end task completion. Procurement leaders should prioritize specialized, industry-specific agents that can integrate deeply into existing workflows rather than settling for generic chat interfaces.
3. Tackling the Data Silo Bottleneck for Agentic Workflows
A major hurdle in deploying an agentic workforce is that autonomous digital workers are useless if they cannot read a company's fragmented, unstructured data. Recognizing this critical bottleneck, venture capital is aggressively funding backend data infrastructure, highlighted by Felicis leading a $7.5 million investment this week in Unsiloed AI. The startup is specifically focused on making dense, unstructured enterprise documents actively usable by AI agents. This mirrors a broader industry push, seen across sectors from energy to finance, to build centralized data foundations that allow digital workers to seamlessly cross boundaries between departmental silos and execute complex, multi-step operations.
Key Takeaway: You cannot deploy a competent digital workforce on top of a fragmented data architecture. Before investing heavily in front-end AI agents, operations leaders must prioritize "data readiness," ensuring their internal documents and systems are actively readable by machine workflows.
The Week the Vendors Agreed on Something
If you spent any time at the big enterprise software conferences this fall, you heard a lot of language about autonomy, outcomes and agents that do the work. Underneath the marketing, though, something more interesting happened. Two of the largest enterprise application vendors described the run-time architecture of their agents in nearly the same terms, and those terms point in a direction that cuts against the popular image of an agent as a model that thinks its way through every step.
Oracle introduced Fusion Claw on September 29 and expanded on it at AI World in late October. In Oracle's own words, "Each Claw Outcome begins with a frontier model that reasons, plans, learns, and adapts," and "Fusion Claw then uses deterministic enterprise computation to execute precisely and at scale." Salesforce, meanwhile, has been steering builders of the new Agentforce toward Agent Script, which its architecture guidance describes as "a hybrid reasoning engine that separates deterministic execution from probabilistic reasoning."
The vocabulary differs, and the products differ a great deal, but the principle is the same. The model is valuable for interpretation and planning. It is a liability when it is the thing that moves the money, posts the journal entry or changes the customer record. I've started calling this the deterministic turn, and I think it will shape how every serious agent platform is built over the next two years.
Why Probabilistic Is a Problem at Run Time
Most business leaders know in a general way that language models are probabilistic. Fewer appreciate how far that goes. A common assumption is that setting temperature to zero makes a model's output repeatable. In September 2025, Thinking Machines Lab published research that tested this directly. They ran the same prompt 1,000 times at temperature zero and got 80 unique completions, with the most common one appearing 78 times. The causes are technical and have to do with how inference servers batch requests, but the business implication is simple. The same input does not reliably produce the same output, even under the settings most people assume are safe.
That is a reasonable tradeoff when the task is drafting an email or summarizing a call. It is a serious problem when the task is closing the books, approving a refund or calculating a commission. Enterprise processes exist because organizations need the same input to produce the same result every time, and they need to be able to prove it afterward. As we explored in "The Trust Equation" (Mar 26), evaluating a non-deterministic system is a different discipline from testing traditional software, and most organizations are still building that muscle.
The field evidence is starting to catch up with the theory. VentureBeat's June 2026 VB Pulse survey of 157 enterprises, a self-selected sample that is best read as directional, found that half had deployed an agent or LLM feature that passed internal evaluations and still caused a customer-facing failure, and one in four had seen that happen more than once. Only 5% said they fully trust automated evaluations. Gartner has predicted that over 40% of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value or inadequate risk controls. Regulators are pointing the same way. Article 15 of the EU AI Act requires high-risk AI systems to achieve appropriate levels of accuracy, robustness and cybersecurity, "and that they perform consistently in those respects throughout their lifecycle." Consistency is now a compliance requirement, not just an engineering preference.
Oracle's Answer: Let the Model Plan, Let the System Execute
Oracle's approach separates the work in time. The frontier model does the thinking up front: it interprets the goal, reasons about the situation and produces a plan. Execution then shifts to deterministic computation inside Fusion, which is the same transactional machinery that has run ERP, HCM and supply chain processes for years. Oracle's October 26 announcement described the Claw runtime as supporting "continuous replanning, deterministic execution, and increased governed autonomy," and Chris Leone, executive vice president of applications development, framed the goal plainly: "The next era of enterprise AI is all about delivering software that increasingly does the work."
The governance pieces matter as much as the split itself. Oracle describes an Enterprise Operating Envelope that captures "an organization's objectives, standard operating procedures, policies, constraints, permissions," along with risk thresholds, decision rights, approvals and escalation paths. That envelope is enforced through what Oracle calls an Outcome Trust Harness, and each run produces an Outcome Receipt that "provides an auditable record of exactly what happened." Customers choose how much automation to allow for each process, up to what Oracle calls "governed full auto execution within explicitly delegated authority."
One detail from a Fusion AI strategy session at AI World made the design intent clear to me. The slides walked through a three-stage run of AI planning, deterministic computation and precise execution, and they marked AI Units as consumed only in the planning stage. Whatever you think of consumption pricing, that is a telling choice. It means Oracle expects the model to be expensive, valuable and limited to the part of the job where judgment is needed, while the steps that touch the system of record run the way enterprise software always has.
Salesforce's Answer: Fence the Model Inside the Run
Salesforce takes a different path to the same destination. Rather than separating planning from execution in time, Agent Script interleaves the two inside a single conversation or process, and draws hard lines around which parts the model controls. Salesforce's architecture guide describes Agent Script as "a declarative, domain-specific language (DSL) that defines everything about how an agent behaves." Within it, "Deterministic logic instructions define conditions and action sequences that execute as code with no LLM involvement," while "Prompt instructions define natural language guidance that the LLM interprets at runtime."
The design rules in that guidance are worth reading closely, because they say a lot about where Salesforce thinks agent failures come from. The guide tells builders that "if you can express a decision as code, it should be written as logic." It describes guard clauses that "prevent the agent from attempting operations when preconditions aren't met." And it describes an available when condition that removes an action from the model's tool list entirely when the condition is false, calling it "a hard platform-level gate." The model can't call a tool it can't see.
My favorite line in the guide is a warning: "If you rely on the LLM to set the gate variable, you've reintroduced the variability the gate was designed to prevent." That sentence captures the whole problem in miniature. It is easy to build something that looks deterministic on a diagram while the model still controls the switch that matters. Good agent design means tracing every decision back to who or what sets it, and making sure the high-stakes ones are set by code, policy or a person.
Two Architectures, One Principle
Put the two approaches side by side and the difference is mostly about where the boundary sits. Oracle draws a line between thinking and doing: the model plans, the platform executes within an envelope, and a receipt records the result. Salesforce draws many small lines inside the flow of work: the model handles language and judgment in the gaps, while code handles conditions, sequencing and access to actions. One is closer to a project plan that gets approved and run. The other is closer to a conversation with guardrails at every turn.
Both map well to the air traffic controller model we use at Arion to describe agent governance. In that model, some actions sit in a green zone where an agent can proceed freely, some sit in a yellow zone where the system warns or asks for confirmation, and some sit in a red zone where the answer is a hard stop. What the deterministic turn adds is a clearer statement of who enforces each zone. The model can propose, interpret and recommend anywhere. But the boundaries of the zones, and the execution of anything in the yellow or red zones, belong to deterministic systems and to people with the authority to approve.
This is also the practical form of the argument we made in "Governance-by-Design" (Mar 5). Governance that is bolted on after the agent is built tends to rely on the agent behaving well. Governance that is designed into the run-time architecture doesn't have to. Oracle and Salesforce are both, in their own ways, moving the control points out of the prompt and into the platform. Other vendors will need to answer the same question, and buyers should expect them to.
Testing a Split System
The deterministic turn also changes how agents should be tested, and this is where many teams will need to adjust. When the model and the deterministic layer have separate jobs, they need separate kinds of assurance. The deterministic layer can be tested the way enterprise software has always been tested: known inputs, expected outputs, regression suites and change control. If a guard clause or an envelope rule is wrong, a test can catch it, and once fixed it stays fixed.
The planning layer is different. A plan produced by a model has to be evaluated for quality and fitness rather than checked against a single right answer, and it has to be evaluated repeatedly because, as the Thinking Machines research shows, the same request can produce different plans on different runs. That means teams need evaluation sets built from real cases, scoring that reflects business risk rather than generic accuracy, and a habit of sampling production plans after go-live, not just before it.
The boundary between the two layers deserves its own attention. Most of the failures I expect to see in the next year will not come from a model writing a bad paragraph or from a rules engine miscalculating a total. They will come from the seam, where a model output quietly feeds a value that the deterministic layer then trusts. A plan that picks the wrong cost center, a classification that routes a case to the wrong approval path, or a field extracted from a document with a small error can all pass through perfectly deterministic execution and produce a perfectly recorded wrong result. Testing the seam means asking, for every value that crosses from the model into the system, what checks it before it is used.
What This Means for Buyers
The deterministic turn gives buyers a sharper set of questions than "how accurate is your agent." Start by asking where the model sits at run time. Does it plan once and hand off, or does it stay in the loop for every step? Neither answer is wrong, but you should know which one you're buying, because it determines where failures can occur and how you will test for them.
Next, ask which steps execute as code and which are interpreted by the model, and ask to see that boundary for a process you care about rather than a demo. Ask who sets the gate variables and whether any of them depend on model output. Ask what record each run produces, whether it shows the plan as well as the actions, and whether your auditors could reconstruct a decision from it six months later. Ask whether a person can review and approve a plan before it executes, and whether that approval can be scoped by risk level, dollar amount or process.
Finally, ask how the economics change. If model consumption is concentrated in planning, the cost profile of an agent looks very different from one that calls the model at every step. That matters for the measurement conversation we covered in "The Board Wants a Number" (Nov 12), because a board that wants to see the return on agent investment will also want to see what drives the cost.
The Catch: Determinism Isn't Free
None of this makes agents safe by default. Deterministic execution of a bad plan is still a bad outcome, and it may arrive faster and with more confidence. When the model's role shrinks to planning, the risk concentrates in the plan. That shifts the governance burden toward plan review, plan validation and the quality of the envelope the plan has to fit within.
The envelope is the harder problem. Oracle's Enterprise Operating Envelope only works if an organization can write down its objectives, procedures, policies, permissions and approval thresholds clearly enough for a system to enforce them. In my experience, a large share of how work gets done in most companies lives in people's heads, in email threads and in exceptions nobody documented. Salesforce's approach has a parallel challenge. Every rule written as logic is a rule someone has to maintain, and the more business logic moves into agent scripts, the more those scripts start to look like a new layer of application code that needs owners, testing and change control.
There is also a flexibility cost. Part of the appeal of agents is that they can handle situations nobody anticipated. The more we fence the model, the more we trade that adaptability for predictability. For high-stakes, high-volume processes, that is the right trade. For exploratory or advisory work, it may not be. And even the best-designed system still needs the ongoing oversight we described in "The Continuous Audit" (Sep 24), because envelopes drift, policies change and plans can be wrong in ways no gate anticipates.
The Bottom Line
The deterministic turn is a sign that enterprise AI is growing up. The first wave of agent enthusiasm treated the model as the worker. The architecture now emerging treats the model as the planner and interpreter, and treats deterministic systems, policies and people as the parts that execute and approve. Oracle and Salesforce took different routes to that idea, and both routes are defensible. What matters is that the principle has moved from research papers and analyst decks into the products that run payroll, close the books and serve customers.
For leaders, the practical takeaway is to stop evaluating agents only on what the model can do and start evaluating them on what the model is allowed to do at the moment of execution. The most useful question in any agent conversation right now is simple: when this thing acts on my systems, what part of that action is probabilistic? If the vendor can't answer clearly, that is your answer.
There is also a lesson here for organizations building their own agents rather than buying them. You don't need Oracle's or Salesforce's platform to apply the principle. Any team can map its agent workflows, mark which decisions require judgment and which require consistency, and move the second group out of the prompt and into code, policy and approvals. Teams that do that work now will find the next wave of platform features easier to adopt, because they will already know where the boundaries in their own processes belong.
Deciding where the model should plan, where code should execute and where people should approve requires a clear view of your processes, your policies and your current governance maturity. The Complete Agentic AI Readiness Assessment includes frameworks for mapping agent decision points, defining risk tiers and approval thresholds, and evaluating whether your policies are documented well enough for a platform to enforce them. Get your copy on Amazon or learn more at yourdigitalworkforce.com. For organizations evaluating agent platforms or preparing to turn on more autonomous execution, our AI Blueprint consulting helps define operating envelopes, design run-time guardrails and build the vendor evaluation criteria that separate governed autonomy from marketing language.

