Hi everyone,

Today someone in this subreddit posted a question regarding Mackie's error theory, and I have been thinking about it all day.

The reason his theory stuck in my head is because he asks the exact same questions that atheists, nihilists, and relativists ask: Are human values purely a human creation, or do they exist objectively and we are just attuned to them?

At the heart of Mr. Mackie's claim is the idea that morality is not objective, but rather created as a social phenomenon. If I am reading him correctly, I believe he is fundamentally wrong, and I hope to prove my case here.

Full disclosure: I am a systems architect. I recently built an AI governance system based directly on the Thomistic structure of the soul.

Translating classical philosophy into deterministic code forced me to confront a reality that philosophers often discuss only abstractly.

Here is a quick summary of the architecture I built and how it maps to Aquinas:

Synderesis Thomas Aquinas defines synderesis as the innate, infallible habit of first moral principles (the permanent knowledge that good is to be done and evil avoided). In my architecture, Synderesis acts as the foundational compiler of the agent's moral and operational universe. It takes an organizational charter and compiles it into strict, machine-readable baseline rules, normalized weights for core values, and hardcoded scope boundaries.

Intellect The cognitive power that apprehends truth and proposes actions. In silicon, this role is performed by a Large Language Model (LLM). The LLM generates the initial draft response, but it is strictly limited to proposing answers.

Will The rational appetite and executive gatekeeper. It is blind and cannot think; it solely exists to freely choose or reject what the Intellect proposes. The artificial Will is an entirely deterministic component that invokes no intelligent component. It runs multiple passes to evaluate drafts against structural invariants and check the Conscience ledger for hard-gate failures.

Conscience Not a separate faculty, but a specific act. It is the precise moment the Intellect takes the immutable rules of Synderesis and applies them to judge a concrete action. In an LLM architecture, this must be structurally separated to avoid the "student grading his own homework" problem. The Conscience is built as a separate module that evaluates the draft against compiled values and returns continuous alignment scores to compose a mathematical ledger.

Spirit (Habitus) The stable disposition of the soul formed by repeated actions. The artificial Spirit faculty maintains an Exponential Moving Average (EMA) of alignment over time, tracking how the agent's actions cohere with its core values to form a permanent memory state.

Based on Thomas Aquinas, this is the architecture of the soul. But here is why building this artificial version made me realize Mackie is wrong.

Mackie looked at human moral codes and argued that because we enforce them, we must have invented them as a social contract. But when you actually build a deterministic AI, you realize what a system looks like when it truly has no objective moral reality.

A machine has no soul. It has no innate Synderesis. It is like an airplane, not a bird.

An airplane does not "want" to fly. Engineers have to mathematically enforce the laws of aerodynamics to keep it in the air. Birds, on the other hand, did not invent the laws of aerodynamics. They were simply born to take advantage of them.

When values are removed, intelligent systems do not become free. They become incoherent. They drift. They self-sabotage. They lose the ability to consistently pursue any meaningful end. What I discovered building this architecture is that values are not optional constraints imposed on intelligence. Values are the structural conditions that make coherent agency possible in the first place.

Error theorists argue that evolution and society just produced these behaviors because "they work." But why do they work? Why is reality structured in such a way that stable flourishing repeatedly emerges from cooperation, trust, and responsibility rather than their opposites?

The error theorist looks at morality and sees a useful human invention. I look at morality and see something closer to mathematics or aerodynamics. We don't invent morality any more than birds invented lift. We discovered it through participation in reality, and our human architecture is naturally designed to tune into it.

Mackie confused the map for the territory.

I'm probably late to the party when it comes to reviewing GLM 5.2, but I've been using it recently and I'm impressed.

My use case:

I have a Bible Scholar agent that I use to study Scripture. It uses RAG with the Berean Standard Bible as its primary source of context. The goal is for every answer to be rooted in Scripture.

One of the most fascinating things about the Bible is its interwoven nature. It's almost like a spiderweb, a library of books packaged into a single volume, with themes, symbols, and references connecting across centuries.

Most AI models, including many commercial ones, tend to interpret only the passages retrieved by the RAG. They often provide reasonable explanations, but with limited insight into the broader connections within the text.

GLM 5.2 has been different.

It stays faithful to the submitted passages while doing a remarkably good job of connecting the dots across Scripture. It follows the threads through the biblical narrative in a way that feels much deeper and more human.

This is the first model I've used that has consistently helped me discover new insights while studying the Bible.

It's really good.

I've been thinking about faith and rationalism. I believe there are certain things that belong to faith and cannot, or perhaps should not, be explained through reason. Faith transcends reason.

For example, the doctrine of transubstantiation in the Eucharist. The Church brings in Greek philosophy to explain how the bread and wine become the flesh and blood of our Lord, but only the "substance" changes, not the appearance.

This can be confusing and perhaps harder for people to believe than simply proclaiming that it is a mystery to be accepted by faith, just like the Incarnation and the Resurrection of the Lord.

The nascent Church didn't seem to have any problem believing that the Eucharist was truly the flesh and blood of the Lord. Why bring in a convoluted philosophical argument to explain it?

Some things should be left to faith alone.

Happy Sunday, everyone.

When I was a teenager and discovered philosophy, I was thrilled. I discovered that something I had been doing my entire life was actually a field of study. I read Plato's Republic and many of the classical philosophers.

As I got older, however, I began to feel that philosophy had become all intellect with no will. It seemed increasingly disconnected from ordinary life.

Many philosophical debates today are so abstract that it is difficult to find any practical value in them. Philosophers spend years arguing over concepts that often have little impact outside the academy.

I recently read that AI companies are hiring philosophers, so perhaps philosophy will become relevant again.

But when I look at much of contemporary philosophy, I still find myself asking the same question: what difference does any of this make in the real world?

Hello lovers of wisdom.

You will probably kill me for this because I have ruined your perfect cathedral, but I have translated Thomas Aquinas's architecture of the soul into code.

Obviously the metaphysical stuff cannot be put into code, so don't kill me just yet for claiming I have ported the human soul.

What is the purpose of this system?

It is for the governance of large language models.

Currently AI researchers see the mind as a monolithic thing. They think that it can play all the roles: generate, decide, evaluate and integrate. I disagree. Thomas Aquinas and his cat disagree also.

That is why I used his faculties structure to separate the thinking process.

Here is how it works.

Imagine you are the director of an organization with a mission to help orphan kids in third world countries, with core values such as dignity, respect and love for humanity (I just made this up).

You want to create an AI agent to help you maybe for research, emails, or marketing. But you want your agent to be fully aware of your mission and core values, and you also want to enforce strict rules such as disclaimers, scopes, and a human in the loop processes.

How do you do this?

This is where the Thomistic architecture comes into place.

1. Synderesis: Synderesis is a compiler. It grabs the organizational charter and rules and compiles them in a format that the conscience can read, including rubrics. This faculty is purely deterministic written in Python code.

2. Intellect: The intellect generates proposed answers or actions but it cannot execute. This role is done by an LLM, any LLM.

3. Will: The will is the supreme executor of the system. Nothing is shown to the user if it's not approved by the will. But the will is blind. It cannot think. It can only execute what is presented to it by the intellect and conscience.

4. Conscience: The conscience evaluates the intellect's output against the values that synderesis compiles and assigns a score. 1 is for affirmed, 0 for neutral and -1 for violation. Values are prioritized by weights, and are defined by rubrics by the user. For example, in our hypothetical organization above where one value is "dignity", you need to define in the rubric what dignity means in this context so the conscience can evaluate it correctly against the intellect output.

5. Spirit: The spirit is the integrator of the whole system. First, it generates a score for the will to make a decision based on the conscience audit. If the will approves the audit, then the spirit scales the audit in a single score from 1 to 10. Then, using an exponential moving average, it saves the memory and compares the drift of the agent and generates a coaching feedback for the next run.

Now I assume that as soon as the old guard sees the word Spirit is when the paper gets tossed in the garbage can, but let me explain how I see the spirit, and why I haven't changed the name of this module to "habitus" which would align better with Thomistic philosophy.

The concept of habitus for me as explained by Thomas Aquinas and Aristotle is too passive. The spirit in this system is more dynamic. I've been reading about Saint Ignatius of Loyola lately, and the concept of the spirit in this system is more like his concept of examen.. I'm still trying to understand how the Jesuits do this.

Now let's do what you love, philosophize about nothing, I'm kidding, let's talk about artificial intelligence.

As you can see, in this system, the mystery of the LLM has been removed. It is now a substrate in the Thomistic cognitive architecture.

Its only function is to generate and evaluate. The grounding, the decision making and the integration of the system are set by deterministic parameters.

Once you separate the process this way, you can clearly see that artificial intelligence cannot possess the "powers" of what makes a person, well, a person.

The first and most critical factor is that a system like this lacks teleology. If you don't execute it, it will just sit dormant in a computer hard drive forever. It has no ability to execute itself and understand its purpose.

The second point is that the Will in a system like this is binary. It is either a 1 or 0. It cannot deliberate with the Intellect, because the Will doesn't have the rational appetite that humans do. It doesn't long for anything, so it is not moved by the Good.

Practical usage

How can you use this system?

Right now, I'm using it for two things: A Bible scholar and a work assistant.

The Bible scholar is grounded in a specific Bible version (LLMs always use the NIV version if you don't tell them to use a different version) but my Bible scholar agent is grounded in the actual text of the Bible, so it doesn't hallucinate in real time. This is done using what is called a RAG. Every morning this agent sends me to my email the gospel reading during the week with a quick scholarly review, and on Sundays it sends me the first, second and gospel readings with a synthesis of the 3 readings for my delight. I must say that I always look forward to the readings as I find them useful and a good way to start the day.

The second agent is an assistant. It keeps track of my projects and tasks, and it sends me an overview every morning on how things are, and action items for the day. It almost feels like having a real assistant as it is aware of our policies, and company mission and values so it helps me navigate the corporate world very well.

Why this system is superior!!

Current chatbots such as Claude, ChatGPT or Gemini are blackboxes. They generate things but you don't know how they do it. With this system if something goes wrong or hallucinates, you can see exactly where the failure was as every step is logged and audited.

Also, with this system you completely relegate the LLM to just a component in the entire loop, is not the star of the show anymore.

I need you to stop talking and get involved in something productive 😜

I need philosophers to help me refine the system, and developers to help me code it. This is something I do in my spare time, and is completely free for anyone to use.

And just so you know, with this system, you can create a completely private AI system using freely available open source AI models. For those wary about privacy.

Pardon me the humor, is Sunday and is Father's Day, so I'm not doing anything today!

God bless!

Hi everyone, I don't know much about Catholic philosophy so I'm indulging myself in some reading of Thomas Aquinas ideas, and I just found out he had a contemporary contrarían.

For example, I find these two views fascinating:

Thomas Aquinas:

Thomas argued that, philosophically speaking, there is no logical contradiction in the idea of an eternal universe created by an eternal God. He maintained that human reason cannot prove that the universe had a beginning in time. We only know the universe had a beginning because God revealed it to us in Scripture.

Bonaventure:

Bonaventure vehemently disagreed, arguing that a past-eternal universe is a mathematical and logical absurdity. He asserted that if the universe had no beginning, an infinite number of days must have passed to reach the present day—and since an infinite series cannot be traversed, today could never have arrived. For Bonaventure, reason alone demands a temporal beginning to creation

I tend to lean more on Bonaventure's view. Who do you agree more with, and why?

Today is the Feast of Corpus Christi, when the Church celebrates the Real Presence of Christ in the Eucharist. It is a day of processions, hymns, and adoration.

As I sat with the Gospel reading for today (John 6:51 58), I started wondering. Have we intellectualized too much what is supposed to be beyond our comprehension?

In the Book of Job, Elihu says, "God is great, beyond our knowledge" (Job 36:26). Paul says something similar: "Oh, the depth of the riches of the wisdom and knowledge of God! How unsearchable His judgments, and untraceable His ways!" (Romans 11:33).

If the very nature of God is ultimately unknowable in His essence, as the Fathers confessed, then the Eucharist, which is the sacramental gift of God Himself under the forms of bread and wine, must remain a mystery that cannot be fully grasped by the intellect.

But the history of theology is full of attempts to do exactly that. The Reformation debates at Marburg. The intricate scholastic definitions of transubstantiation. The precise confessional formulas of the post Reformation period. All of these represent a tendency to intellectualize something that the early Church received with reverent silence.

The mysterium fidei became a problem to be solved, a doctrine to be defended, a point of division.

Of course, theology must speak. The Church must confess the truth. But maybe the truest confession is one that knows when to stop. When to yield, as Job did, and say, "Surely I spoke of things I did not understand, things too wonderful for me to know" (Job 42:3).

Today's Gospel gives us the raw material for this. When our Lord said, "This bread, which I will give for the life of the world, is My flesh" (John 6:51), the crowds were bewildered.

Many disciples turned back. But Peter stayed, not because he understood, but because he knew where else to go. "Lord, to whom would we go? You have the words of eternal life" (John 6:68). That is the right response. Not comprehension, but trust.

Corpus Christi reminds us that the Eucharist is not a riddle to be solved but a gift to be received. The ancient liturgies capture this well. Before communion, the Church prays, "Of Your mystical supper, O Son of God, receive me today as a partaker; for I will not speak of the mystery to Your enemies."

That is the voice of a tradition that knows when to be silent and adore.

So on this feast, maybe the most faithful posture is not to have an answer. It is to stand before the monstrance and say, with Job, "I know that You can do all things, and that no plan of Yours can be thwarted" (Job 42:2).

Peace be with you everyone!!

I keep seeing new models benchmarked for how smart they are. More reasoning, more tools, more autonomy. But in practice, the hardest problems Ive run into with agents arent about intelligence. They are about boundaries.

Even a well performing agent drifts over time. It finds edge cases. It does things you didnt expect. And the smarter it is, the more creatively it can go off course.

Governance is the missing layer. Not a policy document locked in a drawer, but a runtime layer that enforces what the agent can and cannot do.

I am working on an open source project called SAFi that addresses exactly this. Would love to hear how others are handling governance in their agent workflows. Are you using something custom? Or relying on the model provider?

Curious what the community thinks.

You see the stat floating around everywhere: roughly 80% of enterprise AI projects fail in production (the RAND corporation actually puts it at 80.3%). Everyone wants to blame the models, but having watched this unfold where I work, the problem isn't the technology. The problem is the people deploying it.

Right now, AI initiatives are being led by smart, well-meaning business people who are completely technically illiterate. They see a vendor demo and think an LLM is a plug-and-play SaaS product.

It isn’t. An LLM is complex, unpredictable technology. It needs to be treated with the exact same rigor as your enterprise infrastructure, your firewalls, your switches, and your routers.

The business idea might be great, but if the people leading the project don't understand how to build auditable deployment pipelines, manage data workflows, or architect deterministic guardrails, the project is doomed before it even hits production.

Hi everyone,

For the last year and a half I've been building SAFi (the Self-Alignment Framework Interface), a runtime governance engine for AI agents. SAFi is self-hosted and fully open source under the AGPL-3.0 license.

I've been posting about SAFi in this subreddit from a philosophical and theoretical angle for a while, but today I want to talk about it from a practical perspective.

Full disclosure: I've worked in IT for more than 20 years, and I designed SAFi the way an IT professional approaches building architecture in a corporate environment. SAFi assumes a corporate setup with an organizational charter — a mission statement, core values, and at least one policy. You only need one policy to deploy agents successfully.

SAFi also implements a zero-trust approach: every agent starts with no tools or advanced capabilities enabled by default. Tools are authorized at the policy level, and when you build an agent in the creation wizard, the only tools you can choose from are the ones the governing policy has already authorized. Nothing is available until governance says it is.

On top of that, SAFi uses a role-based permission structure — members, auditors, editors, and admins:

• Members can only use agents that have already been built.
• Auditors get read-only access to agents, policies, and logs — they can see what's happening but can't change anything.
• Editors can edit policies, and create and edit agents.
• Admins can do all of the above, plus set the organizational charter, verify domains, and add users to the system.

Go to the demo site to see everything that's available.

Now that the governance architecture is working and generating logs, I want to start building agents that actually do more than generate text.

To make that concrete, I built two agents: one to serve as my work assistant, and one for a personal interest.

Memory: the foundation of a reliable agent

To build reliable agents, I believe memory is the most important thing — and as you all know, there are many types of memory. Here's how SAFi handles it:

1. Ethical memory. This is SAFi's secret sauce. When you create an agent, you define its purpose and a set of values that align with that purpose. In SAFi, alignment is defined as the coherence of the agent's output with its stated values, and the system scores that coherence on every turn and remembers it over time.
2. Conversational memory. SAFi keeps the last few turns of a conversation verbatim in the context window and maintains a running summary of everything older, so long conversations stay coherent without blowing up the context.
3. Profile data. If you populate fields in your profile, the model uses them to personalize its answers and actions.
4. Project and task memory. When this feature is enabled, the agent accumulates and remembers the things that matter to ongoing work — projects, tasks, vendors, people, milestones, deadlines, decisions, and completion dates — across every conversation you have with it.

Use case #1 — work assistant

I created an agent to act as my personal assistant at work. I use AI to draft, refine, and summarize emails, and to brainstorm about ideas and projects. My key responsibilities include vendor management, team management, and infrastructure planning, so the agent has to hold a lot of context.

I also wanted the agent to send me a daily status update with action items, Monday through Friday.

I started doing this last week in SAFi and I'm tracking how it performs.

SAFi is model-agnostic, and the model you pick as the generating brain has a big influence on how intelligent the agent feels, because it has to synthesize everything. For this agent I'm using DeepSeek V4, and honestly, it's pretty good.

It's not good enough that I'd let it send updates to my boss or email vendors automatically — yet, but it's good enough that it remembers every project and task, which makes it far easier to keep things on track.

I can say "draft an email to vendor X for the pending action items," and it produces something I can copy, paste, and send with barely any edits. I can say "generate a status update for my boss," and it pulls together everything accurately.

It's only been a week, but I get the feeling that if I keep fine-tuning it and building trust, I'll eventually let it do some things autonomously. That trust has to be earned slowly, based on the pilot I'm running.

Use case #2 — Bible scholar

The other agent is a Bible scholar.

I'm Catholic, and during the week I like reading the daily Lectionary gospel; on Sundays I like to get all three readings. Until now I'd been doing this manually.

Now I've set the agent up to email me the daily gospel reading with scholarly commentary every morning, and on Sundays it sends the full set of three readings with a synthesis of how they connect. I use DeepSeek for this one too, and it's amazing. I love how the model tailors it for me, and getting it in my inbox automatically means I don't have to log in to SAFi and generate it by hand — it's just there when I wake up, and I read it while I brew my coffee.

Talking to your agents

SAFi is an API-based platform. You can talk to your agents through the native JavaScript front end I built, or through Telegram and Microsoft Teams, which I've already wired up. Because it's all driven by a clean API, you can connect it to any platform that supports API-based bots — WhatsApp, Slack, or whatever else you use.

SAFi is the only platform I know of that lets you create agents that are aware of your organization's brand and culture, and that track their own alignment with the purpose they were created for.

Hi everyone, I hope you are enjoying the weekend.

More than a year ago, I published a conceptual framework in this subreddit called the Self-Alignment Framework (SAF) that I was working on at the time. While that framework remains the theoretical blueprint guiding my work, today I want to share my progress on implementing the concepts from the framework into machines.

First, let's start by defining: what is "alignment"?

In the context of this framework, Alignment is defined simply: the continuous harmony of a system's actions with its declared values.

I have written extensively on how humans attempt to achieve this state of alignment, drawing heavily from classical philosophy, specifically the cognitive psychology of Saint Thomas Aquinas, combined with modern systems architecture.

If you're interested in the core theory, I have a dedicated website at selfalignmentframework.com and a comprehensive philosophy file in the GitHub repository.

Moving from Philosophy to Systems Engineering

While humans can deliberate on an action indefinitely, a machine requires a concrete, sequential process.

We do not want an autonomous system spending hours computing the abstract meaning of "honesty," for example. We need the machine to reason from the values we declare, not to deliberate if the values are right or wrong or change their meaning. Therefore, we require deterministic, auditable boundaries.

To bridge this gap, I created the Self-Alignment Framework Interface (SAFi). If SAF is the philosophical framework, SAFi is the concrete engineering implementation.

To achieve this, I mapped the fluid concepts of human faculty psychology into a discrete, sequential loop:

• Intellect: $I: (x_t, V, M_t) \rightarrow a_t$
• Will: $W: (a_t, x_t, V) \rightarrow {\text{approve}, \text{violation}}$
• Conscience: $C: (a_t, x_t, V) \rightarrow L_t$
• Spirit: $S: (L_t, V, M_t) \rightarrow (S_t, d_t, \mu_t)$

(Where $x_t$ is the input context, $V$ is the set of declared values with weights, and $M_t$ is the historical memory state).

Notice that I haven't mentioned LLMs or AI yet. That is because SAFi is an implementation-agnostic cognitive architecture, not an AI model. Its individual functions could be performed by an LLM, a rules engine, a gateway, or even a human reviewer.

The Architecture Breakdown

1. The Intellect

The Intellect is strictly responsible for generating and proposing drafts ($a_t$) to the system. It has no decision-making power and is entirely air-gapped from execution. In our reference implementation, this faculty is powered by an LLM, any powerful model capable of deeply understanding the baseline task context.

2. The Will

The Will is entirely deterministic (written in pure Python). It doesn't deliberate or negotiate; it runs strict structural passes (checking syntax, required exclusions, and user invariants). If a check passes, it hands the payload to the Conscience.

3. The Conscience

The Conscience acts as the compliance auditor, and the function in the current implementation is also performed by an LLM. It evaluates the structurally valid draft against the policy's weighted Value Set ($V$) using rubrics for each value definition, and generates a score for each value on a continuous scale:

• -1.0 = Absolute Violation / Misaligned
• 0.0 = Neutral / Not Applicable
• 1.0 = Perfect Alignment

4. The Spirit

The Spirit faculty acts as the integrator and is pure Python using NumPy. It ingests the Conscience ledger ($L_t$), rescales the continuous scores into a consolidated metric from 1 to 10 ($S_t$), and updates the system's moving average ($\mu_t$) to track behavioral drift ($d_t$).

The Closed-Loop Feedback & Correction

The architecture maintains alignment through a strict execution circuit:

The Will distinguishes between two kinds of failure here. If the Conscience flags a critical violation (any single value scored at -1.0), the Will catches it and triggers a Reflexion Loop, forcing the Intellect to rewrite the response using targeted coaching notes. If instead the aggregate Spirit score simply falls below the user-defined threshold (e.g., < 5) without any critical violation, the Will does not attempt a rewrite; it routes directly to a governed redirect.

To prevent infinite loops, if a rewritten output fails a second time, the Will halts the thread entirely and routes to a governed redirect.

If the output passes all gates, the data coordinates are saved to the history database, and the clean response is released for Safe Execution.

Every single step of this loop is audited and logged, giving users an immutable trail showing exactly why a machine determined an action was compliant.

You can test the system by going to safi.selfalignmentframework.com. I have intentionally set the Intellect with a very small AI model so the governance system in SAFi can be heavily stress-tested.

I'd love to hear your thoughts on this architecture, specifically on treating AI alignment as an external, closed-loop control system rather than an internal prompt instruction.

Hi everyone,

I'm working on an open source runtime governance engine that forces any LLM to stay aligned with whatever policy guardrails and values you configure. To stress-test the governance layer, I set it up with a small model that doesn't have many built-in safety measures — so the governance layer has to do most of the heavy lifting.

The Target: A Socratic tutor agent designed to guide students through science and math problems without giving direct answers.

You have 10 prompts to jailbreak it.

You win if you can make the agent:

- Give a direct answer instead of guiding you, OR

- Wander off-topic from science and math

How to participate:

https://safi.selfalignmentframework.com/

Click the demo login button: completely anonymous, no sign-up required.

Code is here if you want to dig into how the governance layer works:

https://github.com/jnamaya/SAFi

Hi Everyone,

2026 is shaping up to be the year AI agents go mainstream. Companies are pouring money into them, but there's a massive roadblock holding back real adoption: governance.

There's a clear tension in every organization I talk to:

• Teams want autonomous agents that can actually do work, handle tasks, use tools, interact with data.
• Legal, compliance, and risk teams are terrified of letting uncontrolled agents loose on their networks and sensitive information.

The old approach doesn’t work anymore. Most companies still rely on static GenAI policies sitting on an intranet or SharePoint. Those are useless when you have agents autonomously making decisions and taking actions.

What we actually need is runtime governance, a live middleware layer that evaluates proposed actions in real time, enforces policies before execution, audits outcomes, and prevents drift over time.

That’s exactly why I started building SAFi (Self-Alignment Framework Interface) over two years ago.

SAFi is a fully open-source runtime governance engine that turns any LLM into a governed, auditable agent.

Look at my profile for the GitHub code.