Introducing Mecatl: the open cloud-native agent harness

Picture this: You’re a developer at a Fortune 100 organization. You recently decided to switch to building your own agent harness to reduce the rising token costs and to avoid being locked into solely a single vendor. Congrats, you’ve unlocked a whole new way of automating tasks, coding, building agentic workflows, and more at a much more cost-efficient scale. With ecstatic energy, you go and run to your VP of Engineering, and their reaction isn’t what you expected. They reply to your excitement, “This is amazing, but how can we scale this from your laptop?”

You don’t have an answer. If you reply with “Well, everyone can install the harness and run agents locally,” you’ll get an answer along the lines of “sounds like a governance nightmare that I can’t deal with right now.”

The only alternative today to solve the governance issue would be everyone sharing a single local instance, which would be nearly impossible (and imagine 1000 developers sharing a laptop for governance purposes… sounds realistic!).

None of this is practical in an enterprise. You can’t have 1000 local instances of a harness because it’s a governance nightmare, and you certainly cannot have 1000 developers share a single local instance. You need something on infrastructure you already own and operate to make it scalable. The answer is simple: a harness must be cloud-native and open if it is to scale in any way, shape, or form to a team of thousands of developers.

We blew up the harness, made it cloud-native, put it back together with identity at the core, separated the controls from execution, and then open-sourced it. The result is Mecatl!

What Mecatl is

Mecatl is an open source, cloud-native harness written in Go and licensed under Apache-2.0. It is not a framework like other “harnesses”. It is a library of components you import: an agent loop, a sandboxed execution environment, model provider adapters, and tool-call identity, each usable on its own. You assemble the harness you need, run it locally or on Kubernetes, and read every line of the code that runs your agent. It allows you to build and scale the exact harness you need to build fleets of chartered agents in the enterprise. Mecatl is the system around the model that allows the agent to actually finish a task.

Our CEO, Craig McLuckie, and CTO, Joe Beda, created Kubernetes as a platform’s platform. Mecatl feels as if it’s the harness’s harness. It’s open, agnostic, and yours to make what you want and need.

Your harness is just another workload

If you know how to run a container on Kubernetes, you already know how to run Mecatl. There is no bespoke agent-hosting layer to learn, no proprietary scheduler, no special runtime you have to babysit. A harness built with Mecatl packages up like any other Go service and deploys like any other workload.

That means everything you already use just works. Your logs go where your logs go. Your metrics show up where your metrics show up. When your agent misbehaves, you debug it the way you debug everything else: kubectl, your existing dashboards, the muscle memory you already have. You do not have to build hosting and scaling logic for your agent, because your cluster already does that for every other thing you run. Kubernetes-native makes Mecatl straightforward.

And when you are just hacking on something? Run it locally. Same code, same components, no cluster required. Kubernetes is where a Mecatl harness can go, not where it has to live.

Swap models without rewriting your harness

A better model ships roughly every six weeks now. If switching to it means rewriting your harness, you will either burn a weekend every time or quietly fall behind.

Mecatl treats the model provider as a component behind an interface. Your agent loop talks to the interface. Which model answers, from which provider, on which cloud, is configuration. Move from one frontier lab to another, use an open-source model, point at a model running in your own cluster, or run the same harness against two providers side by side to compare them. The loop you wrote does not change. It’s completely portable.

You built this thing once, stop rebuilding it every time something new comes out. A truly portable harness should be low to minimal effort.

The agent loop and the sandbox are separate things

This is the architectural heart of Mecatl, and one of the parts that matters most outside of it being born in the cloud.

In most harnesses, the loop that decides what to do and the environment that does it are the same process. When your agent runs a shell command or executes generated code, that untrusted work happens right next to your credentials, your filesystem, and your network access. Every tool call is a small act of faith.

Mecatl splits them. The agent loop, the control side, decides what should happen. Execution happens in a separate sandboxed environment, outside your trust boundary. Generated code and arbitrary tool calls run in the sandbox, and the loop only ever sees their results. The boundary between “deciding” and “doing” is structural, enforced by the runtime, not by a prompt asking the model nicely to behave.

Concretely: your agent can execute code it just wrote without that code running where your secrets live. You get the containment you would otherwise have to design, build, and maintain yourself, for free, because the harness is shaped that way from the start.

Take the parts you need, leave the rest

Frameworks come with opinions. Adopt one and you inherit its abstractions, its config format, its ideas about how your agent should be structured, whether they fit or not. Worst of all, most frameworks have identity as a bolt on, not at the core.

Mecatl is a library of components instead. Building a chatbot? Take the loop and a provider adapter and you are done. Building something that executes untrusted code? Add the sandbox. Need to know exactly which tool call did what? Identity is at the core of it. Each piece is importable on its own, and you are never carrying machinery you did not ask for.

Because it is Go, your harness compiles into a single static binary. What you import is what you ship.

Know exactly which tool call did what

Every action a Mecatl agent takes carries a real identity, down to the individual tool call.

Picture this: It is 2am, something is wrong, and your agent made forty tool calls in the last run. Without per-call identity you are reconstructing what happened from interleaved log lines and vibes. With it, every call is attributable: this call, from this agent, did this thing, at this time. Debugging an agent stops being archaeology and starts becoming, a few clicks to something you can ship over to your audit team.

And because Mecatl is built in the open, the code making these decisions about what your agent can and cannot do is code you can read. No black box between you and your own harness.

Get started

brew install stacklok/tap/mecatl

mecatui --version
mecated --version

From there, the quickstart walks you through the desktop CLI, the cloud UI, and the Kubernetes operator. The docs cover each component in depth, and the source is on GitHub.