The Model Proposes, the Runtime Decides
When building AI agents for critical tasks, never let the LLM hold the keys or make unilateral execution decisions. In Soot, the model only proposes tool calls; deterministic runtime policies and operator grants decide what actually runs.
A recent dev.to post caught our attention with an instructive headline: *"The AI Understood My Payment Request. My Rust Code Refused It."*
In the author's setup (an open-source project named SpendGuard), natural language payment requests are parsed by a large language model. The model parsed the prompt accurately, extracting the intended recipient and amount. But when that proposed payload hit the execution layer, the deterministic Rust runtime flatly rejected it: the transaction exceeded configured spending caps and targeted an unverified address.
The core takeaway is vital for anyone building agentic systems: An LLM is an untrusted parser proposing actions. It should never hold the keys or make unilateral execution decisions.
Never Hand the Keys to a Language Model
When teams first build AI agents, the most common trap is granting the model too much autonomy. Some pass private signing keys or sensitive API secrets directly into agent environments, letting the model initiate external network requests based solely on its own prompt reasoning.
No matter how advanced foundation models become, their output remains probabilistic:
- They can be misled by prompt injections embedded in untrusted external data.
- They can misinterpret numbers, units, or recipient identifiers.
- They lack any real awareness of budget boundaries, legal liability, or organizational risk.
Think of an LLM as an enthusiastic, fast-reading junior assistant. They are exceptionally good at parsing ambiguous requests and proposing draft actions. But any action that alters external state—moving funds, modifying production databases, dispatching messages—must pass through a deterministic gatekeeper enforcing strict rules.
What a Deterministic Policy Runtime Must Do
In a resilient architecture, the runtime environment acts independently from the model, enforcing non-negotiable boundaries:
- Hard caps and allowlists: Regardless of what the model proposes, the runtime verifies deterministic constraints: Does the proposed action exceed per-transaction limits? Does it breach the daily threshold? Is the recipient on an explicit allowlist? If a rule is violated, execution aborts immediately before any external call is made.
- Outbox state logging before network dispatch: State transitions must be recorded locally in an outbox pattern before touching external APIs. If network interruptions occur, the system avoids ambiguous states or accidental duplicate executions.
- Transparent payload decoding for human review: Before critical operations are confirmed, the raw payload should be decoded into plain, unambiguous terms for the operator. The human reviewer validates what will actually happen, rather than relying on the model's self-reported summary.
The Soot Boundary: Permission Checks Before Tool Execution
Soot's architecture is built around this exact separation of concerns.
When you run a Soot inside the Nest desktop app or on your own server, interactions follow strict runtime boundaries:
- The model only proposes tool calls: The model examines the conversation and context, then outputs a structured proposal: *"I want to call tool X with arguments Y."* It cannot directly spawn arbitrary OS processes or open raw network sockets.
- The host runtime verifies grants and scopes: The Soot host runtime sits between the model and the tools. Before any tool runs, the runtime checks:
+ Has the operator explicitly granted this tool to this Soot? (Following the Forge principle: *installing is not granting*—installing a pack does not permit execution). + Are the referenced file paths, data tables, or API endpoints within the assigned scope?
- Deterministic denial at the boundary: If a model proposes accessing a file outside its authorized level or invoking a tool without an active grant, the runtime rejects the call on the spot and returns a clear permission denial. The model cannot bypass the host runtime.
One Small Soot, One Clear Task, Clear Evidence
This reinforces Soot's guiding principle: One small Soot, one clear task, clear evidence.
- One small Soot: Rather than creating a monolithic agent with sprawling capabilities, keep each Soot small, armed only with the minimal tools needed for its specific role.
- One clear task: Defined boundaries, explicit inputs, and verifiable completion criteria.
- Clear evidence: Every proposed tool call, grant verification, and execution result is recorded in an audit trace on your machine. You always know what was executed, when, and with what proof.
AI models provide incredible flexibility in natural language understanding. But safety, repeatability, and peace of mind come from deterministic runtime enforcement where you, the operator, remain firmly in control.
---
Learn more about Soot's permission model and execution boundaries at trysoot.com/docs. Download Nest to test locally at trysoot.com/download.