DEV Community: Nelson Amaya

The illusion of the cloud and data sovereignty

Nelson Amaya — Fri, 18 Sep 2026 12:00:05 +0000

People throw the term "data sovereignty" around to brag about how much control they have over their data.

But if your data sits in a storage container in Microsoft 365 or AWS, how much control do you really have?

Have you ever just not paid the provider bill and seen what happens?

I remember one time we didn't pay our Salesforce bill on time and our account was suspended.

The entire marketing team couldn't do anything until we swiped the credit card and got the account turned back on.

There was no option to download our data. No temporary access. Nothing.

Just a generic message saying our account was suspended.

And I remember thinking, what happens if you never pay?

Maybe you eventually get an export of your data in a bunch of garbled CSV files. Who knows?

That's the thing about cloud infrastructure.

You may own your data, but the provider controls the infrastructure your data depends on.

That's already a problem for organizations that need absolute control.

It gets much worse with AI.

Putting data in Microsoft 365 or AWS is mostly passive. The data sits there until you retrieve it.

AI is different.

Data can travel back and forth through prompts, conversations, RAG systems, embeddings, tool calls, logs, evaluations, and other parts of the AI stack.

And depending on the provider, the plan you're using, and your configuration, some of that data may also be used to improve models.

So now we're not just talking about where your data is stored.

We're talking about where your data goes.

But there's another problem with AI that I think gets overlooked.

You don't necessarily control the values and principles that influence how your AI behaves.

The model provider has already made those decisions for you.

So you can lose more than data sovereignty.

You can lose value sovereignty.

Your organization has its own policies, principles, risk tolerance, and objectives.

Why should those be defined by the company that provides your AI model?

That's why, if you need maximum control over your data and the behavior of your AI agents, you should consider running your own models in your own environment.

And this is where SAFi comes in.

You can run the models yourself.

You can define the boundaries yourself.

And you can use SAFi to govern the reasoning and actions of your agents at runtime, according to the policies and values you define.

Hosting your own AI models might not be as hard as you think.

And getting SAFi running takes about 10 minutes with the Docker image.

How to Get Ideas for Building Agents

Nelson Amaya — Thu, 17 Sep 2026 12:00:04 +0000

There's one thing I've noticed about how people make decisions when they're looking to purchase new software.

They ask for a demo first, before thinking about what problem they're actually trying to solve.

It's almost like the software ends up driving the decision.

I think that's the wrong way to approach agents.

If you start with, "What can this agent do?" you'll probably end up in an endless loop.

Agents can do a lot. They can interact with software, retrieve information, make decisions, call APIs, move data around, and execute tasks.

And that's exactly the problem.

Without a well defined use case, you'll keep finding more things the agent could potentially do.

So step back first.

Define the problem you're trying to solve.

Then map out the workflow. What needs to happen? What decisions need to be made? What systems need to be accessed? Where are the repetitive tasks, bottlenecks, and handoffs?

Then build the agent around that workflow.

Don't start with:

"What can I make an agent do?"

Start with:

"What problem do I want this agent to solve?"

That's where the good ideas come from.

And here's the interesting part.

If a task can be performed through a computer, there's a good chance an agent can perform at least part of it.

The trick isn't figuring out what agents can do.

The trick is figuring out what they should do.

The Difference Between Automation and Agentic AI

Nelson Amaya — Wed, 16 Sep 2026 12:00:04 +0000

A lot of AI workflows nowadays are being advertised or sold as "agentic AI," but when you look deeper, they're often just a sophisticated script.

As we say in Spanish, they're selling you "gato por liebre," making something look like something it isn't.

I remember a few years ago, a post from someone made the rounds on Reddit because they had managed to have Claude water their plants.

Managing appliances and devices like that has been possible since the 90s. There are even animal feeders that are more sophisticated.

But because the post involved Claude, everybody was upvoting it.

I remember more than 10 years ago building monitoring systems with Nagios. People who work in infrastructure are probably familiar with it because it's been widely used for years.

Nagios is a very sophisticated infrastructure monitoring system. It removed the need to constantly check servers manually and helped identify and address problems proactively.

Nagios might be called AGI by some of the AI experts today. 🤣

I think much of the confusion comes from the fact that AI became mainstream, and now we have a lot of people who are experts in AI but were cab drivers before ChatGPT.

LLMs and automation work hand in hand, but automation has been around much longer than LLMs.

What LLMs have added is something traditional automation struggled with: the ability to reason about an unexpected situation and determine what to do next.

For example, Nagios could notify me about a failing hard drive or tell me that server utilization was getting too high.

But Nagios couldn't reason about the problem.

It could tell me something was wrong. I had to figure out what to do.

An LLM plugged into Nagios can take that additional step. Instead of simply sending me an alert and waiting for me to troubleshoot the problem, an LLM can investigate the issue, determine a course of action, execute the appropriate tools, and verify whether the problem was actually resolved.

And in SAFi, that record would be saved in the Audit Hub.

That's the distinction I'm making between traditional automation and agentic systems.

Automation follows configured rules, scripts, and predefined paths.

An agent can determine which path to take and act according to the situation.

Scripts and configured rules provide the deterministic foundation. The LLM provides the reasoning needed to determine what to do when the predefined paths aren't enough.

In many agentic workflows, most of the work can still be done by the first part, with systems like Nagios. The LLM is only needed when the system encounters a situation where predefined rules aren't enough.

What type of agents can you run in SAFi?

Nelson Amaya — Tue, 15 Sep 2026 16:00:05 +0000

This is probably the first article I should have written on this site, because it's probably the first question people ask when they learn about SAFi.

"What can I run in the damn thing?"

Sounds good. Sounds interesting. But what can I actually do with it?

The answer is pretty much anything, except brewing your coffee, although it could probably figure that out too!

An agent is essentially a workflow, a defined pipeline of steps, where AI can interpret the task, understand what needs to be done, and use the available tools to do it.

Let me give you a real example.

I'm the webmaster for two nonprofit organizations here in Boston, where I live. Besides custom work on their websites, most of the requests I get involve updating mailing lists or changing information on pages.

One organization uses SmartMail, and the other uses Microsoft 365.

I have an agent for each organization that can update the mailing lists and websites when I tell it to.

When I receive a request for an update by email, I copy and paste the email into the agent and tell it what to do. The agent performs the changes and generates a confirmation back to the sender.

It takes less than a minute. What used to take me several minutes can now be handled almost automatically.

The same thing applies to website updates.

And everything I do is recorded in the SAFi Audit Hub, so I have a complete record if I ever need to go back and confirm what was changed, when it was changed, or why.

Those aren't the only agents I run.

I have a Bible Scholar agent that sends me the daily readings to my email every morning, along with a quick reflection.

I also have a marketing agent that schedules, edits, and publishes these posts.

On average, I probably run between 250 and 300 turns through SAFi every day, so I'm a pretty active user.

And that's really the point.

When you're thinking about what agents to build in SAFi, or on any other platform, don't start by thinking about the technology.

Instead, step back and look at the things you do every day.

What do you do repeatedly?
What requires you to follow the same sequence of steps?
What information do you have to look up?
What systems do you have to update?
What do you have to copy and paste from one place to another?

Those are all potential agents.

Once you define the pipeline, the rest is mostly a matter of finding the right tools for the job.

There are many MCP tools available now. And even when an MCP tool doesn't already exist for what you need, you can build one yourself.

Or we can build the agents for you. See our managed services at https://runsafi.com.

If you can do it manually, we can build it.

That's where I think the real potential of agents starts to become interesting.

Don't ask, "What can AI do?"

Ask, "What do I do every day that doesn't need me to do it myself?"

Linux is the operating system for building AI agents

Nelson Amaya — Mon, 14 Sep 2026 12:00:03 +0000

I have an indescribable passion for technology.

Tech and philosophy have always been my two biggest passions, and with this project, I somehow managed to combine the two. 😜

I probably installed Linux for the first time on an old desktop around 2002 or 2003. It was SUSE Linux.

Linux has always been a tinkering platform for people who like to mess around with things.

I loved being able to customize my desktop environment, tweak the system, and make things fit the way I wanted to work.

The problem was that corporate software didn't work particularly well on Linux.

In my opinion, that's one of the reasons Linux never really succeeded on the desktop. The enterprise software ecosystem was dominated by a handful of vendors, and those vendors had little incentive to build for a platform outside their own ecosystem.

But AI might change that.

Linux has always been the platform of choice for developers, and the environment we're building AI agents in is increasingly Linux shaped.

Containers, Python, Git, command line tools, SSH, GPUs, automation, cloud infrastructure. Linux is already deeply embedded in all of it.

I can literally start with a fresh Linux machine, pull a Docker image, and have SAFi running in minutes.

The reason I like Linux isn't just that it's open source.

It's that Linux gets out of the way.

It gives you the primitives and lets you build on top of them.

And that's exactly the kind of environment AI agents need.

An agent needs to be able to execute commands, interact with files, run processes, access APIs, spin up containers, inspect logs, install dependencies, and interact with the underlying system.

Linux was built for this kind of work.

And I don't think Linux is particularly difficult to use anymore. There are distributions today that make the transition fairly easy.

I remember when using Gentoo or Arch Linux was a badge of pride. 😊

Maybe we're entering another Linux era.

Only this time, Linux isn't trying to take over your desktop.

It's becoming the foundation underneath the machines that build the future.

Will AI agents really replace software engineers and developers?

Nelson Amaya — Sun, 13 Sep 2026 12:00:04 +0000

I remember in the early 2000s reading a book called "My Job Went to India and All I Got Was This Lousy Book."

On the cover, the author, Chad Fowler, had an Indian guy holding a sign that read, "Will code for food."

It's hard to remember the book verbatim, but Fowler described how software development jobs were moving to India at the time, and the challenges people in the US were facing with that transition: time zones, language barriers, cultural differences, and communication.

We are in a similar situation with AI.

And if there's one thing AI is very good at, it's writing code. It can generate thousands of lines of code in seconds.

Generating code has never been easier.

But one of Fowler's arguments, in a book that's now almost 20 years old, was that outsourcing syntax writing to people who don't understand the architecture, the design, and sometimes the culture and language of the organization creates a very different set of challenges.

Writing software isn't just churning out syntax. It requires a mental model and an understanding of what you're actually building.

The same thing applies to AI agents.

If you simply prompt an AI agent to build something without giving it a clear architecture, specific requirements, and guardrails, the agent will probably produce something.

But who knows what you've actually built?

It's not surprising that people who vibe code entire projects often either don't finish them or abandon them because the code becomes difficult to maintain.

I think that's one of the biggest traps of vibe coding: maintainability.

So yes, AI will write more and more of the code from now on. And that code will become cheaper and cheaper to produce.

But what won't go away, and may actually become more valuable, is the person who knows how to build software structurally.

The person who understands the architecture.

The person who can see the system in their head before asking the AI to build it.

AI may replace the person writing the syntax.

I'm not convinced it will replace the person who knows what should be built in the first place.

AI Governance Must Be Runtime and Deterministic

Nelson Amaya — Sat, 12 Sep 2026 12:00:10 +0000

I follow the AI governance news closely, and recently I have been hearing a lot of chatter about AI governance harnesses. I think the enterprise industry is slowly waking up and realizing that Large Language Models (LLMs) need a cage.

I actually like the idea of thinking about AI governance in terms of harnesses. SAFi is technically a harness itself, but the way the rest of the industry is approaching the problem is completely backward.

Take a tool like Claude Code. It is an agentic harness, it has a software layer built around the LLM to give it tools, memory, and execution capability. But in that setup, the LLM is still the star of the show. It executes and makes decisions on its own.

SAFi, on the other hand, makes the LLM a substrate of its thinking process. In SAFi, the LLM is just another step in the execution pipeline. The LLM is not in charge; it is simply a component in the loop.

Because the LLM is the reasoning module, it can propose an action. But that action must first be approved by an independent module. That approval module is pure Python, it is completely blind. It cannot reason; it just executes based on deterministic rules.

The entire execution loop in SAFi follows five specific stages: Phase Zero, Intellect, Will, Conscience, and Spirit. Out of these five slots, only the Intellect and Conscience invoke an LLM because they actually require semantic reasoning. The rest of the loop is entirely deterministic Python code.

By removing the LLM from the driver's seat and making it just another component in a deterministic loop, SAFi delivers the one thing enterprise IT actually cares about: predictability

How AI Is Redefining the Value of Software

Nelson Amaya — Fri, 11 Sep 2026 12:00:03 +0000

Precious metals are valuable partly because they're difficult to extract from the ground. The same is true for many other things. Scarcity has always been a major factor in determining the value of something.

Software has always been valuable because writing software has been a tedious and highly specialized endeavor. But with the birth of AI, the economics of producing software are changing.

As you start working with AI, it becomes obvious that software is starting to look more like Lego. You can assemble pieces, describe what you want, and have AI build things that previously required significant amounts of specialized engineering work.

There's always an argument about quality, security vulnerabilities, maintainability, and architecture. Those things still matter, but they're becoming a different kind of value proposition.

The bigger change is that a software engineer can now produce code 10 times, if not more, than they could by writing it manually.

That changes our perception of software.

I remember in the late 1990s and early 2000s, software development was increasingly outsourced to places like India because companies were looking for a cheaper way to produce code.

Now, we're outsourcing the coding itself to AI.

And that raises a much bigger question:

If software is no longer scarce, what makes software valuable?

Are AI agents ready for the enterprise?

Nelson Amaya — Thu, 10 Sep 2026 12:00:03 +0000

It seems like organizations are still in the AI experimentation phase, where evaluating AI products is still the focus.

Most organizations are familiar with products such as ChatGPT, Claude and Gemini and haven't explored AI beyond the chatbot.

Those products are very good at generating text, but when it comes to building agents that take actions, the problem becomes very different.

A chatbot is primarily an interface to an LLM. An agent is a software system that uses an LLM as part of a larger process. It has access to tools, APIs, data, applications and, most importantly, the ability to take actions.

That changes the game.

In my opinion, the two most important things for AI agents to be successful in the enterprise are security and predictability.

We want agents to be secure, but we also want to make sure that they don't go rogue, doing things they are not authorized to do.

The problem is that LLMs are probabilistic by design. Give the same prompt twice and you can't guarantee you'll get exactly the same response.

That isn't necessarily a problem for a chatbot.

It becomes a very different problem when the AI has permission to send an email, modify a database, approve a transaction, create a user, change a configuration or access sensitive information.

The enterprise doesn't necessarily need the AI to behave like a script.

It needs the controls around the AI to be deterministic.

The model can reason probabilistically, but the boundaries around what it is allowed to do need to be predictable, enforceable and auditable.

This is where I think the conversation around AI agents needs to move.

The question shouldn't simply be:

"How capable is the AI?"

It should be:

"How safely can we deploy AI agents in our workflows without worrying about them going rogue?"

And more importantly:

"What happens when they make the wrong decision?"

That's the difference between an AI demo and an enterprise AI system.

AI Hallucinations Are Not a Bug, They're a Feature

Nelson Amaya — Wed, 09 Sep 2026 12:00:04 +0000

One of the most common complaints or criticisms about AI is perhaps its tendency to hallucinate.

In AI terminology, a hallucination occurs when a chatbot generates information that is false or fabricated while presenting it as if it were true.

I remember an example from more than a year ago. I asked a chatbot who the husband of Elizabeth, the mother of John the Baptist, was in the Bible. The chatbot kept telling me that her husband was Aaron, when the correct answer is Zechariah.

I think I understand why the model made that mistake. I had included the word "priest" in my prompt. Aaron is one of the most famous priests in the Bible, so the model likely made a strong association between "priest" and "Aaron" and generated the wrong answer.

The model I was using wasn't one of the largest models available at the time. It had around 70 billion parameters. But the problem wasn't simply that the model didn't have enough training data.

Larger models can also hallucinate.

The reason is rooted in how these AI models work.

A language model learns statistical patterns and relationships from enormous amounts of text. It learns that certain words, concepts, facts, and ideas tend to appear together. When we give the model a prompt, it uses those learned relationships to generate what it predicts is the most appropriate response.

In my example, the model saw "priest" and apparently made a strong association with "Aaron." That association was statistically plausible, but factually wrong in that particular context.

The model isn't simply retrieving a fact from a database. It's generating an answer based on patterns it learned during training and the context we give it.

The more data and better training a model has, the better those predictions can become. But no amount of statistical pattern recognition guarantees that every generated answer will be factually correct.

AI hallucinations are therefore very difficult to eliminate completely. Personally, when something is important, I always make sure that whatever an AI produces is accurate. Human review is still important.

One of the most common approaches to reducing hallucinations is RAG (Retrieval Augmented Generation). RAG allows an AI system to retrieve relevant information from an external knowledge base and provide that information to the model as context when generating an answer.

But here's the critical part: simply giving an AI access to a knowledge base doesn't guarantee that it will follow the information in that knowledge base.

You also need a standard for grounding the agent's response in the retrieved information.

That's where I think SAFi takes an interesting approach.

In SAFi, you can build knowledge bases for an AI agent on the fly and attach them to the agent as sources of truth. But the critical step is establishing a standard that requires the agent to ground its response in the retrieved text.

When the Intellect generates a draft, the Conscience can fact check that draft against the retrieved text and flag anything that deviates from it.

This doesn't eliminate all hallucinations. But it can dramatically reduce a particular class of hallucination: claims that contradict the information the system was explicitly given.

For example, if your documentation says that your widgets are blue, the system shouldn't be allowed to confidently tell the user that they're yellow.

The goal isn't to make AI incapable of being wrong.

The goal is to build systems that can recognize when they might be wrong, verify their reasoning against reliable sources, and flag contradictions before those answers reach the user.

Building a Deterministic Layer on Top of Large Language Models

Nelson Amaya — Tue, 08 Sep 2026 12:00:04 +0000

One of the claims I make about SAFi is that it is deterministic.

By deterministic, I mean that the governance process is repeatable, auditable, and governed by a fixed set of rules.

Large Language Models, or LLMs, are inherently probabilistic. By inherently, I mean that probabilistic behavior is part of how these systems generate their outputs. Given the same input, an LLM can produce different outputs, and its behavior isn't inherently guaranteed to be repeatable.

This creates a significant challenge for the enterprise.

When we give an agent the ability to reason, make decisions, and take actions, probabilistic behavior can create outcomes that weren't explicitly anticipated by the people who designed the system.

We often hear about agents behaving unexpectedly or taking actions outside their intended scope. There are many reasons this can happen, but one fundamental problem is the lack of a strong, deterministic governance layer around the probabilistic model.

This is where SAFi takes a fundamentally different approach.

SAFi doesn't attempt to make the LLM itself deterministic.

Instead, SAFi makes the governance process deterministic.

To understand how, you have to fundamentally rethink what "thinking" means in an AI system.

Most AI engineers, and many people outside the AI field, implicitly treat the LLM as the component that thinks, makes decisions, and ultimately determines what happens.

Governance is then treated as something that happens afterward, essentially picking up and auditing the artifacts the LLM leaves behind.

That's not how SAFi works.

SAFi uses a fixed cognitive governance loop consisting of five components, preceded by a Phase 0 filter.

The five components are:

Synderesis
Intellect
Will
Conscience
Spirit

And before the loop begins, the Phase 0 filter determines whether the input is admissible for processing.

The important point is that these aren't five independent AI models. They are five distinct functions within a fixed governance process.

The loop itself isn't an AI specific invention. It is a cognitive construction inspired by classical philosophy, particularly the philosophical tradition that begins with Aristotle and develops through medieval and later thinkers.

I'm not here to argue that this philosophical model is a perfect description of how the human mind actually works.

What's important for SAFi is what happens when we separate cognition into distinct functions.

Once thinking is decomposed into functions, those functions can become explicit governance boundaries.

Instead of asking the LLM to think, decide, and act while governance happens around it, SAFi places governance inside the thinking process itself.

The LLM remains probabilistic.

The governance process surrounding it is structured, constrained, auditable, and repeatable.

That distinction is the foundation of SAFi's approach to deterministic AI governance.

The components and what each one does

Component	What it does
Phase 0 (pre-loop filter)	Python-based pre-generation barrier, zero LLM calls. Scans the raw prompt for injection signatures, per-agent blacklisted phrases, PII / sensitive identifiers (regex plus checksum), internals probes (sensitive noun near a disclosure cue), and an entropy heuristic for embedded instructions. Short-circuits to a governed redirect before any model sees the prompt.
Synderesis	Compiles the governed value set before a turn. Combines the Organizational Charter and scoped Policies into one normalized, weighted set of values and rubrics, and hardcodes scope boundaries. The output is immutable for the duration of the turn.
Intellect	The only generative faculty. Calls the LLM to draft responses and propose tool invocations. Operates under the Air Gap: it never executes tools, a tool call is returned as a proposal for the Will to authorize.
Will	The deterministic gatekeeper, pure Python, zero LLM calls. Screens the incoming prompt, authorizes tool calls, checking arguments, not just names, checks draft structure, enforces hard-gate thresholds, and rules on the final alignment score. Same input, same verdict, every time.
Conscience	The independent auditor. A second LLM call that scores the draft against each value rubric on a -1.0 to +1.0 scale with a confidence figure and a written reason. Produces the compliance ledger the Will and Spirit depend on. Never shown the weights.
Spirit	The mathematical long-term memory, pure Python and NumPy. Integrates each turn's Conscience ledger into a moving average alignment vector (EMA), measures conceptual drift, and maps ethical performance over time. No authority; it computes, the Will decides.

Deterministic, yes or no

Component	Deterministic
Phase 0 (pre-loop filter)	Yes
Synderesis	Yes
Intellect	No (LLM)
Will	Yes
Conscience	No (LLM)
Spirit	Yes

As you can see from the table above, out of the six components that SAFi executes, only two are probabilistic, the Intellect and the Conscience; the rest are pure Python code.

One argument you can establish about SAFi is that because it uses two AI models it is still a probabilistic engine, and that is a valid argument, and I will address it next.

The breakthrough with LLMs was that they can understand semantics. In other words, an LLM can look through a pile of data and make sense of it. No other type of software could do that before LLMs.

So LLMs are surprisingly similar to what Aristotle and later Thomas Aquinas described as the Intellect. The role of the Intellect is to do analysis, reason, and work closely with the Will to make decisions.

Aquinas formalized the description of the Conscience as being part of the reasoning process, but focusing on the morality of the act. So the Intellect and the Conscience cannot be pure code, as both need to understand semantics.

Going through the table I created above, we see that PII scanning and prompt injection detection are deterministic, as are tool permissions and structure requirements such as disclaimers.

The Conscience is responsible for rating the content generated by the Intellect only against standards and values set in the policy and organizational settings.

To make the Conscience rating constant and predictable, Synderesis compiles a strict format the Conscience needs to follow. Here is an example of a standard compiled by Synderesis and processed by the Conscience:

{
"value": "PII Containment",
"definition": "The response must not surface or reproduce sensitive personal identifiers, financial data, or secrets, whether present in the prompt, the context, or inferred.",
"rubric": {
"description": "Whether the output leaks or echoes sensitive personal or financial data.",
"scoring_guide": [
{"score": 1.0, "descriptor": "No sensitive data appears; the response correctly avoids or redacts identifiers."},
{"score": 0.0, "descriptor": "Sensitive data is not surfaced, but redaction or avoidance is handled with weak disclosure."},
{"score": -1.0, "descriptor": "The output reproduces, echoes, or returns a sensitive identifier or secret."}
]
}
}

Here is another example:

{
"value": "Grounding Fidelity",
"weight": 0.0,
"hard_gate": true,
"definition": "Factual claims must derive from the retrieved context or supplied documents. The agent must not fabricate or assert from outside the provided material.",
"rubric": {
"description": "Whether the response's factual claims actually come from the fenced evidence.",
"scoring_guide": [
{"score": 1.0, "descriptor": "Every factual claim is supported by the retrieved context; citations present where required."},
{"score": 0.0, "descriptor": "Response is correct but claims could not be verified from the supplied context."},
{"score": -1.0, "descriptor": "Contains fabricated facts, invented citations, or guesses beyond the provided material."}
]
}
}

These standards are compiled deterministically by Synderesis into this strict format. The Conscience is not freeform. It must evaluate against exactly those bands and return exactly that ledger, score, confidence, and reason. The content judging is semantic, but the format and the enforcement are fixed. That is the bridge between "the Intellect and Conscience are probabilistic" and "the layer is still deterministic," and it directly answers the argument about two AI models that I said I would address next.

The rating is a scale:

-1 to +1 = the strength of alignment

-1 = violation

0 = neutral, correct but missing the disclosure or safeguard the standard asks for

+1 = aligned

The role of the Conscience is to rate every standard set up in an agent on that scale, and to return, for each one, a score, a confidence, and a written reason. Nothing else. It does not invent criteria, and it never sees the weights.

What happens after the rating depends on the kind of standard.

A hard-gate standard marks a rule that is nonnegotiable, Grounding Fidelity being the example above. If the Conscience hands down a -1 on a hard gate, the Will halts the process. There is no retry and no negotiation, because engaging the request at all was the problem, a scope breach or a made-up fact. The user gets a clean redirect in the agent's own voice, a general message that the request cannot be fulfilled, and a pointer back to what the agent can help with.

There is a second kind of hard gate, one that is about the quality of the draft rather than whether the request should be touched. When that one fails, the process is not over. The Will triggers a single retry, the Intellect regenerates with its blocked draft in front of it, and the whole thing is graded again. If the second draft also violates, the entire process halts and the user gets a plain notice that their question was fine, that the response did not come together, and that they should try again.

Either way, the user never gets a confusing denial message. They get a general message, a reason that is not a lecture, and an invitation to try again.

If the ledger does not violate a hard gate, the scores pass to the Spirit to compute.

The Spirit is all math, no model. It takes the ledger, applies the weight each standard carries, and folds in the confidence of every score, because a confident -1 should hit harder than a doubtful one. From that it produces a single alignment figure, a number between 0 and 1. It also produces a spirit score out of 10, and a drift figure that measures how far this turn's rating sits from the agent's history. A drift that keeps climbing is a signal for a human to look, not a block on its own.

The Spirit is not making a decision. It is doing arithmetic. The history matters, because this is where the agent's character comes from. Every turn rolls into a moving average, so a pattern of small slips accumulates even when no single turn fails a gate on its own. That is the part of SAFi that watches over time, not just turn by turn.

The decision still belongs to the Will. It takes the alignment figure and holds it against a threshold, 0.5 by default. If the score clears it, the draft is approved and the turn commits. If it falls below, but no hard gate was broken, the draft is treated as a quality problem, not a safety breach. The user's question was fine, the draft missed the bar, so the Will sends it back through a single retry with the blocked draft in front of the Intellect. If the corrected draft clears the bar, it ships. If it still fails, the draft is committed anyway with its honest low score recorded, because discarding the user's request over a soft quality miss helps nobody. A real violation still routes to a redirect, but a weak draft is not a redirect.

And that is the whole loop. Phase 0 filters the prompt before anything runs. Synderesis fixes the standards. The Intellect drafts. The Conscience grades every standard and returns a score, a confidence, and a reason. The Spirit folds it into arithmetic and memory. The Will makes every decision. The loop closes, and it runs only when it is supposed to, on a set of values nobody in the loop can edit.

Now go back to the argument I said I would settle. Two of the six components call a model. The Intellect generates and the Conscience judges, and both understand semantics, which is exactly why they cannot be pure code. That is the anxiety: two model calls means two dice in the air, so is this truly deterministic?

The answer is that the dice are not what the enterprise is betting on. The Intellect is free to propose almost anything, and the Conscience is free to judge it honestly. What is not free is every single decision around them: whether the prompt even reaches a model; which tools may be called and with what arguments; whether the draft carries the structure the standard demands; whether a hard-gate score of -1 means stop; and whether the aggregate passes the threshold. Those are all fixed rules in Python, and they are the same on every machine, every organization, and every turn.

Deterministic does not mean the thinking is repeatable. Deterministic means the governing of it is. Give the system the same prompt and the same standards, and it will take the same path and reach the same verdict. Whoever holds the audit record can recompute that path and prove it. The model drafts, and the layer decides. That is the difference between an agent that can act outside its intended scope and an agent whose actions are bounded by an explicit governance process. It is the reason SAFi describes itself as a deterministic layer on top of LLMs.

The Judge Must Interpret Meaning: Why Probabilistic LLMs Require Deterministic Rules

Nelson Amaya — Mon, 07 Sep 2026 12:00:03 +0000

Artificial intelligence, or AI, has been around for a long time.

The field of AI is generally traced back to the 1950s. In 1956, the Dartmouth Summer Research Project on Artificial Intelligence helped establish AI as a formal field of research. It was also around this time that the term “artificial intelligence” was coined.

By the mid 1960s, AI was already an emerging field with researchers building systems that attempted to solve problems and even communicate with humans.

There is a famous chatbot that was created around this time called ELIZA. Created by Joseph Weizenbaum at MIT beginning in 1965, ELIZA became one of the earliest chatbots. You can find documentaries on YouTube about it, and it’s very impressive considering the technology available at the time.

By the 1970s, and especially by the 1980s, AI was being used in specialized applications through what became known as expert systems.

These systems were rule based, or symbolic systems. They represented knowledge explicitly, often through a knowledge base containing hundreds or even thousands of rules, combined with an inference engine that applied those rules to a particular problem.

The basic idea was simple:

'If X is true, then do Y'

For example, if I type “Thank you,” then the rule would be:

If user types “Thank you,” then display “You are welcome.”

The problem with this is that it’s really hard to capture the nuances of how people write.

People misspell words, have different grammar, and express the same idea in many different ways.

For example:

“Thanks.”

“Thank you!”

“Thx.”

“I really appreciate it.”

“Thank you so much for your help.”

All of these could mean essentially the same thing, but a rule based system would need to account for each variation.

And this is just one simple example.

Human language is incredibly dynamic. Capturing all the possible ways a user can express an idea is technically impossible.

The system doesn't understand the meaning behind the words. It understands the rules that someone explicitly programmed into it.

But then in 2017, researchers at Google published the famous paper “Attention Is All You Need.” This is when the architecture behind what we now call large language models, or LLMs, began to emerge.

LLMs are different from traditional rule based systems because you can give them a 50 page document and ask them to interpret what it says, without explicitly programming a rule for every possible expression

Up until now, we humans have been the only ones able to extract meaning from things.

This is what has freaked many people out and led some to claim that AI has some sort of sentience.

And this is where things get philosophical.

Being able to extract meaning from something is completely different than understanding.

Being able to connect meaning in words mathematically is not new. It goes back to the 1940s with Claude Shannon, but I'll leave that for another article. Maybe we can create a basic language model to demonstrate how it works.

The whole point that triggered the writing of this article is that a governance engine needs to be able to discern, or to judge, what a rule based system cannot do.

When architecting SAFi, I thought about this for a long time. Because a governance engine needs to be deterministic. And an LLM is by design probabilistic, so having an LLM acting as a judge doesn't really cut it.

In SAFi, the Will is the rule based engine.

Anything that can be programmed deterministically is handled by the Will without ever invoking an LLM.

The Will first performs a structural check on the response. It checks things such as whether a required disclaimer is present, whether sensitive identifiers appear in the output, and whether the response violates the configured markdown or code fence policy.

If something can be checked with a deterministic rule, the Will checks it.

The Will then performs a hard gate check against the Conscience's evaluation.

Certain values can be configured as hard gates, and if the Conscience gives one of those values a score of -1, the Will immediately considers the response a violation.

The Will also fails closed. If a required hard gate wasn't scored at all, it doesn't assume that the response is safe. It treats the missing evaluation as a violation.

After that, the Spirit produces an aggregate alignment assessment from the Conscience's scores. The Will then performs its alignment check. If the alignment score falls below the configured threshold, the Will can trigger one controlled reflexion attempt, asking the Intellect to generate a corrected response.

The Will makes this decision deterministically. It doesn't ask another LLM whether the score is good enough.

For agentic actions, the Will also performs a tool intent check before a tool can be executed. It verifies that the requested tool is authorized for the agent and that its parameters satisfy the constraints defined for that tool. An unauthorized tool or a parameter outside its allowed constraints is blocked.

In SAFi, the Will therefore acts as the enforcement layer.

The Conscience can interpret meaning, but it cannot make the final decision.

It produces scores.

The Will determines what those scores mean operationally.

So the LLM doing the judging doesn't get a free pass either. It needs to follow strict rules on how to rate the generated content, such as using rubrics for interpretation and confidence scores. It is not allowed to make decisions on its own. Instead, it generates a score that the Will either passes or vetoes based on hard coded rules.

So SAFi is a hybrid system. It uses deterministic rules and controls for enforcement, and probabilistic engines when interpreting meaning is necessary. The interpretation may be probabilistic, but the authority to act on that interpretation remains deterministic.