Skip to content

How we build autonomous AI agents

Illustration eines Roboters der eine Wolke auf einen Chip montiert.

In the first part of this series, we introduced Muro. He lives in Slack, takes care of dependency updates and handles tasks that would otherwise require someone to create a ticket, open a repository and get going.

The more interesting question is: What happens between an @muro in Slack and a finished task?

Because an LLM on its own isn't an agent yet. You can write to Claude:

«Check our open dependency updates and fix them.»

Claude will probably think that's a great idea. It just doesn't have a repository, Git access, a shell, credentials, project context or permission to change anything. So we build it a workplace.

From @muro to finished task

Slack-Konversation mit @muro: Playwright-Updates werden in mehreren Repositories erledigt
Muro in Slack

We didn't want to create a new interface for Muro. That's why he lives where we coordinate our work anyway: in Slack.

«@muro can you take care of this dependency update?»

For the person in the thread, that's just a message. Behind it, a clear sequence kicks off:

  1. Identity: Our connector binds the person's Slack identity to the request. An agent shouldn't act regardless of who gave it the job.
  2. Session: The thread gets an isolated OpenCode session. That way, context is preserved across multiple messages and work steps.
  3. Context: Muro reads the relevant AGENTS.md information and loads the matching skills.
  4. Repository: Our Git integration prepares the code in a dedicated workspace.
  5. Execution: Muro changes code, runs checks and opens a merge request if needed.
  6. Result: Status and outcome land back in the original Slack thread.
Slack Thread
     ↓
Connector + Identity
     ↓
OpenCode Session
     ↓
Context + Skills
     ↓
Git Proxy / Repository
     ↓
Code + Tests + Actions
     ↓
MR / Resultat
     ↓
Slack Thread

So the Slack thread is both the interface and the session boundary.

Systemarchitektur von Muro mit Slack, OpenCode Engine, GitLab, Jira und Notion
Muro Systemarchitektur

The workplace is a Docker container

Muro doesn't run on some random developer's laptop. He runs in a Docker container called smartcode-assistant on our own infrastructure.

Inside it, isolated OpenCode sessions run. Every Slack thread has its own working context and its own workspace. Tasks don't interfere with each other, and we decide exactly what's available in the Linux environment.

It's a developer's workplace. Just a controlled, disposable one.

Git credentials shouldn't be lying around

One of the less pleasant parts of the build was Git authentication. Muro needs to read repositories and push branches. Long-lived Git tokens inside the container would be a pretty bad starting point for that.

So our solution is an integration Git proxy. The agent talks to Git through this proxy. Credentials are bound dynamically to the respective identity and action, and never have to sit permanently in the container or on disk.

That was a lot more work than:

«Just give Claude a Git token.»

But it's exactly details like these that separate a demo from an agent we actually let do real work.

Tools turn the model into a colleague

Muro can read repositories, push code, run shell commands, kick off tests, reply in Slack threads and, depending on the task, work with Jira, Notion, DatoCMS or deployments.

That sounds like a feature list. Technically, it's the most important security question of the whole system: Tool access is where an agent's real power lies. The model can reason. The tools decide what actually happens as a result.

A coding agent doesn't just need the shell to write code. It also has to be able to run builds, linters and tests. Otherwise it produces changes but has no way of telling whether they work.

Not every agent needs every tool

That's why we don't give every agent access to every system. A coding task needs Git and a shell. A support task might need Jira, Notion and logs. The smaller the toolbox, the clearer the context and the smaller the attack surface.

Same principle as with software permissions in general: least privilege. Now applied to agents.

Skills turn tools into workflows

Just because an agent can use Git doesn't mean it knows how we use Git. That's exactly what skills are for. They connect capabilities with our processes.

The tool says: “I can operate Git.” The skill says: “This is how you prepare a repository at smartive, create a branch and open a merge request.”

On top of that, there are agent-wide rules and project-specific context in files like AGENTS.md. This separation keeps us from ending up with one gigantic master prompt that crams in dependency management, CMS rules and half the company's history all at once.

Autonomy isn't a boolean

One of the hardest parts of the build wasn't the model. It was the question: What is the agent allowed to just do?

Muro is allowed to change code, push branches, create merge requests, run checks and, depending on the task, make changes in external systems.

But: He's never allowed to merge a merge request on his own or push directly to protected branches like main. The same goes for final production approvals.

Why we leave the merge to humans

Up to the merge, Muro can take on almost all of the work: analyze the problem, build a solution, run tests and deliver the change in a reviewable state. After that, mechanisms we already have kick in: CI, code review and approval.

A merge request is the established handover point between “Someone built something” and “We accept this change”. Whether that someone was a human or an agent is secondary as far as the process is concerned.

That's why human-in-the-loop isn't a step backward. An agent can handle 90 percent of a task and stop before the irreversible action. How far it's allowed to go depends on the risk. A Slack reminder isn't a database migration in production.

We don't build one big agent

Muro isn't interesting because there's a huge prompt somewhere that can do everything. His capabilities are modular: interface, session, model, tools, skills, permissions and execution environment.

Depending on the use case, we combine these into different agents with different tools and different limits on autonomy. The agent becomes a configured work environment rather than an all-knowing AI personality.

And then you hit the next problem

At some point, your agent can check out a repository, change code, run tests and open merge requests. Then everything should be great.

Of course it isn't.

Because in a real software project, it runs into implicit architecture rules, three patterns for the same problem, outdated documentation, dead code and global CSS rules from 2019.

And suddenly the agent is no longer the biggest problem. The repository is.

That's exactly what part 3 of this series is about: how we build repositories for autonomous agents.

Because what we've learned so far is this: Making an agent autonomous is only half the job. The other half is an environment in which it can work reliably.

Ein Mann mit Brille, kurzen dunklen Haaren und Bart steht mit den Händen in den Taschen da. Er trägt ein marineblaues T-Shirt und Jeans in Orange.

Written by
Josh Wirth

Artificial Intelligence|September 2026

Got a similar challenge on your plate? Let's talk.

More Articles