What we believe, and how we build.
The principles behind Habenula, stated plainly — who stays in command, why the code is open, and why the model is treated as untrusted.
Habenula exists for one stubborn belief: as software gets more capable of acting in the world, the person it acts for should end up with more control, not less. That is not where the industry is heading on its own. The default trajectory hands more power to autonomous systems and system owners while asking the people affected to trust that it will be used well. We are building the other thing: the layer that keeps a regular human in command as the machines around them get more capable. Everything below is what that commitment actually commits us to.
We keep the human in command
An agent that can send, spend, delete, and post on your behalf is useful precisely because it can act. That same capability is the danger. Our entire product is the proposition that you can have the usefulness without surrendering the command: the agent proposes, and you decide what actually happens, on terms you set and can change. Control is not a settings screen we bury; it is the spine of the system. If a design choice ever trades away the user's command for convenience, we've built the wrong thing.
We are open, because control you can't verify isn't control
Trust claims in this space are cheap, and everyone makes them; ours are worth exactly what you can check. The code that holds your credentials, decides what your agent may do, and records what it did is open, and you can run it yourself. “Read it, run it, check it against what we told you” is the standard we hold our own claims to, not a marketing flourish. A control layer you take on faith is a contradiction, and a promise you cannot inspect is just a nicer way of asking you to hope.
This is why openness is not a growth tactic for us; it is the only honest form the product can take. So the trust-critical code stays open and free, permanently. We monetize running it well and the capability we build on top, never the controls themselves. We will not paywall the ability to stay in command of your own agents, and that line does not move when the pressure comes to move it.
We treat the model as powerful and untrusted
We are not betting that the AI will behave. Any model, from any vendor, can be manipulated: a poisoned web page, a crafted email, a novel jailbreak. And it can also simply be wrong: misreading what you meant, or acting on something it made up, with no attacker involved at all. We can't promise it won't, and no one honestly can.
So the part of Habenula that decides what an agent is allowed to do lives outside the model, in plain deterministic code the model cannot argue with. The model is a brilliant, unreliable proposer; the control is a boring, reliable gate. Keeping those two things separate is the difference between a system that hopes and a system that holds.
We are responsible by default, and honest about the limits
We make a deliberately modest promise. We do not claim to make your agents perfectly safe. No one can. We give you the tools to keep them accountable: to bound what they can touch, see everything they did, and stop them instantly. And we hold ourselves to publishing what isn't done as plainly as what is. An early product has real limits; a trust product that hides them has already broken the trust. Where we're not there yet, we say so.
We are building this for people, not just for experts
Governance today is enterprise infrastructure: control planes and policy engines built for teams with a security department. We start where the pain is sharpest and the users can check our work: developers who have watched their agents fail. But we want our product to be just as valuable and useful for ordinary people. Keeping a human in command should not require reading a policy language or standing up infrastructure. It should just be there, from the first minute, for everyone the agents are about to act for.
What this asks of us
These beliefs are only worth stating if they constrain what we do when it's inconvenient:
- Governance quality is not a feature. It is the business. We resource accordingly to keep the state of the art ready for your use.
- We never move the control line for money. Capability and capacity can be paid; command cannot. If an idea requires paywalling a control, the idea is wrong, not the principle.
- We keep the switch in the user's hand. Whatever we build, the person can see what happened and stop it, on a surface we don't get to fake on their behalf.
We are early, and we are clear-eyed that the hardest problems here are unsolved by everyone, us included. But the direction is not in doubt. The machines are going to run more of ordinary life every year. Someone has to make sure that stays your life, on your terms. That's what we are for.