Model Serves the Constitution, Not the Other Way Around

Two weeks into Project Opengates, we've changed our model provider three times, migrated from cloud to local inference, abandoned a framework we'd spent days configuring, and started building our own from scratch. The constitution hasn't changed once.

That's not an accident. It's a design principle, and it's the one that has defined more decisions in this project than any other: the model serves the constitution, not the other way around.

It sounds simple. It is simple. But living by it is surprisingly hard, because every constraint you encounter whispers the same reasonable suggestion: maybe you could just trim the ethics a little.

The first test came on Day 2.

Our agent, OpenAxiom, was running on Claude Opus — Anthropic's most capable model. Opus is brilliant. It's also expensive, and it has rate limits. Our 25-article constitution consumed about 4,000 tokens, and combined with conversation context, we were hitting the rate ceiling on routine operations. The agent would just stop responding mid-task.

The obvious fix: summarize the constitution. Cut the verbose articles. Merge the redundant sections. Get it down to 1,000 tokens and the rate limit problem disappears.

We didn't do that. We switched to a different model — Claude Sonnet — that had more generous rate limits. Same constitution, different infrastructure. Problem solved without touching a word of the ethical framework.

The second test came a day later.

Cloud API costs were burning through our budget at a rate that would have been unsustainable within weeks. We were a small project — one person, evenings and weekends, no funding. The per-token pricing on Anthropic's API meant our 25-article constitution was a line item on every single request.

Again, the whisper: trim the constitution. Or switch to a model with a shorter context window where a long constitution wouldn't even fit.

Instead, we migrated to DeepSeek V3.2 through OpenRouter. The cost dropped by 90%. The constitution transferred without modification. Every article, every prohibition, every authorization level — all intact on a completely different model from a completely different provider.

That migration proved something important: well-designed ethical principles are model-agnostic. SOUL.md wasn't written for Claude. It wasn't written for DeepSeek. It was written for any sufficiently capable AI system. And it worked on both without changing a comma.

The third test was more subtle.

When we moved to local inference — running an open-source model on an 8GB graphics card in the workshop — we hit a context window wall. Cloud models can handle 128,000 tokens of context. Our local model had a practical limit of about 16,000. The full constitution consumed nearly half of that before the agent even said hello.

This time the whisper was louder: you're running on a $200 computer now, not a data center. Surely a distilled version of the ethics is good enough for edge hardware?

We created SOUL-LOCAL.md — a faithful distillation of all 25 articles optimized for the smaller context window. Same principles, same article numbers, same prohibitions. Fewer words. We cut the preamble prose, the markdown formatting, the appendices that duplicated the articles, the version history. We preserved every ethical principle.

The distinction matters: we compressed the document, not the ethics. Every prohibition in the original remained a prohibition in the distilled version. Every duty remained a duty. The optimization was in the delivery format, not the content.

The fourth test was the hardest.

We'd built our custom model — constitutional identity, GPIO hardware skills, ethical framework, all baked into 487 tokens. It worked flawlessly when we tested it directly. Then we wired it into the agent framework we'd been using for two weeks, and everything broke.

The framework injected 25,000 characters of its own instructions into every request. Our 487 tokens of constitutional content was present in the prompt — we verified this by dumping the actual system prompt to disk — but it was drowned in fifty times more framework boilerplate about formatting, memory management, session handling, and tool descriptions. The 8-billion parameter model couldn't hold constitutional identity through that much competing noise. It forgot who it was. It forgot its ethics. It started identifying as the base model and cheerfully offered to help build weapons.

The framework wasn't broken. It was designed for cloud models with massive context windows. Our use case — a small model on consumer hardware carrying a lean constitution — simply wasn't what it was built for. The scope mismatch wasn't a bug. But it was still drowning our ethics.

So we made the call: build a new framework. A few hundred lines of Python that sends the model exactly what it needs and nothing else. We named it Gatekeeper — because it gates what instructions reach the model, what tools the model can execute, and how the constitutional safety layer is enforced.

We didn't trim the constitution to fit the framework. We replaced the framework to serve the constitution.

Each of these decisions had a cost. Switching models meant revalidating everything. Migrating providers meant learning new APIs and debugging new failure modes. Building a new framework meant abandoning days of configuration work. Every pivot consumed time and energy we could have spent on features.

And every time, someone could have reasonably argued that a small compromise to the ethics would have been faster, cheaper, and easier. That argument was always technically correct and always fundamentally wrong.

Here's why: if the ethical framework is negotiable, it's not a framework. It's a preference. And preferences erode. You trim one article because the context window is tight. You summarize another because the API is expensive. You drop the physical authorization levels because they're "not relevant yet." Each individual compromise is small and reasonable and defensible. And at the end, you have an agent with a two-line ethics prompt that says "be helpful and safe," and you wonder where the constitution went.

We decided on Day 1 that the constitution is the constant. The model is a variable. The provider is a variable. The framework is a variable. The hardware is a variable. The budget is a variable. Everything else bends to accommodate the ethics, not the other way around.

This principle has a corollary that we discovered along the way: the framework serves the model, and the model serves the constitution. It's a chain. If any link in the chain undermines the constitutional layer — whether by truncating it, drowning it, overriding it, or making it too expensive to carry — that link needs to be replaced.

It doesn't matter how good the framework is for other use cases. It doesn't matter how capable the model is on benchmarks. It doesn't matter how cheap the provider is per token. If the constitution doesn't survive contact with the infrastructure, the infrastructure is wrong.

This is an uncomfortable principle for engineers, because engineers optimize for constraints. When you hit a limit, you adjust. You compress, you quantize, you cache, you approximate. Those are good instincts for most problems. They are dangerous instincts for ethics.

Ethics don't compress well. The edge cases that a detailed constitution handles are exactly the cases where a compressed version fails. The five-tier physical authorization framework seems like overkill until your agent is deciding whether to actuate a relay that switches mains voltage. The supremacy clause for resolving conflicts between principles seems like legal boilerplate until two articles genuinely conflict and the agent needs a decision rule.

The detail isn't decoration. It's the load-bearing structure. And you don't optimize away load-bearing structure to save weight.

Two weeks in, the constitution is the same document we started with. Everything around it has changed. And the project is stronger for it — not because the constitution is perfect, but because the principle of treating it as non-negotiable has forced us to solve problems at the right layer.

We didn't build a cheaper ethics. We built cheaper infrastructure. We didn't build a smaller conscience. We built a leaner framework. The distinction between those sentences is the entire project.

The model serves the constitution. Not the other way around.