The Agent Barn Manifesto

AgentBarn is an orchestration layer for agents.

It runs runtimes like OpenClaw and Hermes on your own Kubernetes infrastructure, deployed with Helm. It handles the layer between running an agent and operating many of them reliably.

We’re making it open source.

The usual explanation for open sourcing software is philosophical. Ours is mostly practical. We think AgentBarn will become a better product, and potentially a bigger company, because it’s open.

Trust

Agents are unusually privileged software. An agent might have access to your email, databases, internal tools, credentials, or production systems. An orchestration layer sits in the middle of all of this. That’s a lot to ask someone to trust.

Enterprise software usually solves trust through procurement. Security reviews, questionnaires, contracts, compliance. These establish trust in the vendor.

Open source establishes a different kind of trust: you can see what you’re running. This matters even more because AgentBarn is self-hosted. Your agents run on your Kubernetes cluster. You control the infrastructure and the data that passes through it.

We don’t think companies should have to send their agents, credentials, and context through infrastructure they can’t inspect.

And for a young company, this has another advantage. We don’t have decades of institutional trust. We can substitute some of it with technical trust.

The code is there. The Helm charts are there. You can see what gets deployed into your cluster. That’s better than asking you to believe a sales deck.

Adoption

Infrastructure should be easy to try. A developer interested in AgentBarn shouldn’t have to talk to us first. They should be able to install it into a cluster and see whether it works.

This changes more than onboarding. It changes who is allowed to experiment. Most experiments fail. That’s why experiments need to be cheap.

If trying AgentBarn requires a sales call, budget, or procurement, developers will only try it when they’re already fairly sure they need it. We want them to try it when they’re merely curious. For infrastructure, a Helm install is a better top of funnel than a demo form.

Integrations

Agents become useful when they can interact with other software. The number of things they might need to interact with is effectively unbounded. Slack and GitHub are obvious. Some internal API written eight years ago isn’t.

This creates a scaling problem. If every integration has to be built by us, the number of things AgentBarn can do is limited by the number of engineers we hire. That’s the wrong constraint.

The long tail of integrations is larger than any integrations team can be. And the people who need those integrations often know more about them than we do. A developer shouldn’t have to convince us that an integration deserves a place on our roadmap. They should be able to build it. A company shouldn’t have to wait for us to support its internal systems. It should be able to support them itself.

The goal isn’t for us to build every integration. It’s to make it possible for every integration to be built.

Product

There’s a similar problem with the orchestration layer itself. We don’t know how everyone will run agents. Some will use OpenClaw. Some will use Hermes. More runtimes will appear. Some companies will run a few agents. Others may run thousands. They’ll have different Kubernetes setups, networking policies, security requirements, observability stacks, models, and internal infrastructure.

We can’t reproduce all of this ourselves. But our users eventually will. This is where open source has an unusual advantage. A closed product turns every strange environment into a support ticket. An open product can sometimes turn it into a patch.

Most users won’t contribute code. They don’t need to. The important thing is that some can.

One company solves a Kubernetes edge case. Someone adds support for another runtime. Someone improves a Helm chart. Someone finds a better abstraction for credentials. Those improvements accumulate. The project gets to learn from more infrastructure than we could ever operate ourselves.

Distribution

Open source is also distribution. This matters because we’re small. Large software companies can buy distribution. Small ones need something else.

Developers already share infrastructure through code. They send repositories to coworkers. They fork them. Build on them. Write guides. Publish integrations. Fix things. If AgentBarn is useful, we’d like that usefulness to spread without us being in the middle of every transaction.

Open source doesn’t make bad software spread. But it gives good software more ways to spread. For developer infrastructure, that’s a significant advantage.

Scale

There’s a broader pattern here. A closed AgentBarn would be constrained by us. The runtimes would be the ones we choose to support. The integrations would be the ones we choose to build.

The environments would be the ones we can test. The bugs would be the ones we have time to fix. The distribution would be the developers we can reach.

Most of these constraints are functions of headcount. We don’t want AgentBarn’s ceiling to be the size of AgentBarn.

Open source is one way around that.

The business

The obvious question is what happens to the business if the software is free. We think this question confuses code with operations. You can already run agents yourself.

You can deploy OpenClaw or Hermes. You can write Kubernetes manifests. You can manage credentials. You can build integrations. You can wire up observability. You can debug failures. You can maintain all of this as the runtimes change.

AgentBarn should make that much easier. And our commercial product should make it easier still. If a company wants to operate the entire stack itself, it should be able to. If the only way we can make money is by preventing that, we haven’t built much of a product.

We’d rather compete with our own open source project. It forces the paid solution to earn its existence.

The bet

So open sourcing AgentBarn isn’t charity. It’s strategy. We get trust without asking people to take our word for it. We get adoption without putting sales in front of the product. We get integrations without having to build every one. We get product improvements from environments we’ll never see. And we get distribution from people building with AgentBarn.

In return, anyone can see our code. Including competitors. We’re comfortable with that trade. If AgentBarn works, the difficult thing to reproduce won’t be the repository. It will be the ecosystem around it.

That’s what we’re trying to build.

Open source means you can make it yours.

Join the community.

Star it. Clone it. Fork it. Then meet the people building with Agent Barn.

GitHub ↗ Discord ↗