Comparisons between SAFi and techniques such as reinforcement learning from human feedback, or RLHF, are useful only up to a point. Constitutional AI is a closer conceptual comparison because it introduces explicit principles into the process of generating and evaluating responses. Even so, these approaches address a different layer of the problem.
RLHF and Constitutional AI primarily shape how a model behaves. SAFi governs how an AI agent operates.
That distinction matters because an AI agent is not only a language model producing text. It may interpret requests, reason about possible responses, decide whether to act, call tools, access information, modify data, and produce an answer that must be accountable to the organization deploying it.
The conventional architecture: the model at the center
Much of today’s AI governance consists of filters, classifiers, guardrails, monitors, and policy checks placed around the model.
The general pattern looks like this:
- A request reaches the model.
- The model generates a response or proposes an action.
- External controls inspect the input, output, or tool request.
- The system allows, blocks, modifies, or records the result.
This architecture can be valuable. External controls can detect prohibited content, restrict certain actions, and provide monitoring or enforcement. They are often necessary parts of a responsible deployment.
But the architecture still places the model at the center of the process. Governance is positioned around the model as an additional control mechanism. In many systems, the evidence needed for explanation and audit is also collected after the model has produced its output or proposed its action.
That creates a basic separation between execution and governance:
- The model produces the draft.
- The governance system evaluates the draft.
- The monitoring system records what happened.
The controls may be effective, but governance remains an external activity surrounding the primary intelligence.
SAFi’s architectural difference
SAFi takes a different approach. It treats governance as an internal runtime loop through which the agent operates.
The model is not the center of the system. It is a replaceable reasoning component, or substrate, used by the loop to perform particular cognitive functions.
SAFi’s sequence is structured around five faculties:
- Values define what the agent is expected to uphold.
- Intellect interprets the request and develops a response or proposed action.
- Will determines whether the response or action should proceed.
- Conscience evaluates the decision against the governing values and policies.
- Spirit integrates the result and determines the final governed outcome.
Values are established before the turn begins. The remaining four faculties provide the practical reasoning sequence for applying those values during the turn.
This means governance is not merely applied to an agent after it has acted. Governance is the process through which the agent’s response and actions are formed, evaluated, authorized, and recorded.
The model becomes a component, not the authority
This is the conceptual shift at the center of SAFi.
In a model-centered architecture, the model is treated as the principal source of intelligence. Surrounding systems attempt to constrain, inspect, or correct its behavior.
In a SAFi architecture, the model supplies reasoning capacity, but it does not define the governing values, authorize its own actions, or serve as the final source of accountability.
The organization’s charter and policies define the governing values. SAFi applies those controls through the runtime loop. The model can be replaced or upgraded without requiring the organization to surrender its governance structure or audit history to a model provider.
This supports model independence:
The model may change. The governing charter, policies, enforcement process, and audit trail remain under the organization’s control.
That is different from training a model to prefer certain outputs. It is a runtime architecture for governing an agent regardless of which model performs the reasoning.
Governance before delivery and before action
SAFi evaluates each governed turn before an answer is returned and before a tool runs.
This distinction is particularly important for agentic AI. A response can be reviewed after generation, but a tool call may create an external consequence. It may read sensitive information, write to a system, send a message, change a record, or initiate another operation.
SAFi therefore treats governed action as part of the same runtime process. Tool calls are checked against the agent’s permitted allow-list before execution. Reads and writes can be held to different standards, and the action taken is recorded alongside the decision that authorized it.
The relevant question is not only:
“Was the final answer acceptable?”
It is also:
“Was the proposed action authorized before it occurred, and can we show why?”
Auditability is produced by the loop
In many systems, auditability is treated as an additional observability feature. Logs are collected around the model after an interaction has taken place.
SAFi’s audit trail is different in principle. The record is generated as the governed turn proceeds because the loop itself contains explicit decision points.
A governed record can include:
- The original request
- The model-generated draft
- The value-by-value evaluation ledger
- The enforcement decision
- The policy version in force
- The tool call and action record
- The resulting supervisory or review state
Auditability is therefore not only a record of what the model said. It is a record of how the governed runtime handled the turn.
This is why “runtime” is central to SAFi’s positioning. The governance process is not an offline assessment performed later. It is part of the execution path.
SAFi is not simply another filter
A filter generally asks whether an input or output matches a prohibited or permitted condition.
SAFi asks a broader set of questions:
- Which organizational values apply?
- What policy governs this situation?
- What response or action has been proposed?
- Is the response consistent with the governing values?
- Is the action authorized?
- Which policy version was in force?
- What decision was made, and why?
- Does the agent remain consistent with its charter over time?
This does not mean SAFi guarantees correctness, prevents hallucinations, or eliminates bias. Grounding, retrieval quality, model behavior, and human review still matter.
The distinction is that SAFi makes these questions part of the governed execution process rather than treating governance as a separate inspection step.
A more precise comparison
A concise comparison might look like this:
| Approach | Primary purpose | Role of the model | Governance position | Audit result |
|---|---|---|---|---|
| RLHF | Shape model behavior through preference-based training | The trained system being optimized | Embedded during training | Training and evaluation artifacts |
| Constitutional AI | Guide model behavior with explicit principles | The model applying or responding to principles | Closely associated with model behavior | Model-development and response-evaluation artifacts |
| External guardrails | Detect or restrict inputs, outputs, and actions | Primary generator or decision-maker | Surrounding control layer | Filter, policy, and event logs |
| SAFi | Govern agent behavior and action at runtime | A replaceable reasoning component | Internal governance loop | Draft, value ledger, decision, policy version, and action record |
These categories can overlap. SAFi can be used alongside model training, constitutional principles, retrieval, filters, and security controls. The point is not that one approach makes all others unnecessary.
The point is that SAFi addresses a different architectural question:
How does an organization govern an AI agent while it is reasoning and acting, rather than only shaping the model beforehand or inspecting its output afterward?
The core difference
SAFi’s difference can be stated simply:
SAFi is an open-source runtime governance engine for agentic AI. It treats the model as a reasoning substrate inside a values-driven loop, evaluates responses and tool calls before they proceed, and produces the audit trail as part of execution.
This gives organizations control over the governing values, policies, action permissions, and records that define their agent’s behavior.
The model remains important, but it is no longer the whole system. The agent operates within an organizational governance process that is explicit, inspectable, model-independent, and designed for action as well as conversation.
The strongest way to evaluate this distinction is not to compare slogans. Clone the repository, run the demo, inspect a governed audit trail, and examine whether the recorded decision process matches the claims.
Top comments (0)