Skip to content

AI Agents in Software Development: How Muro Takes Work Off Our Hands in Slack

Eine illustratorische Darstellung eines Cloud Agents. Dargestellt als Wolke mit Sonnenbrille und Aktenkoffer

At smartive, autonomous AI agents now roam around in Slack. They don't just answer questions. They work.

Our agent Muro can independently open repositories, change code, run tests, update merge requests and fix problems in CI/CD pipelines. We give him a task in Slack — and, ideally, get the result back a few minutes later.

For example: @muro can you fix all open Playwright updates in our corporate websites?

Muro then looks for the affected merge requests, checks out the repositories, makes the necessary changes, runs the existing checks and pushes the fixes.

This is where AI is getting especially exciting for us right now. Not because an LLM generates even better code. But because we can hand it entire tasks. And by now we've figured out pretty well which of them work.

What Muro actually does for us

It started with a few small experiments. By now, there are several categories of work we regularly hand off to Muro.

He keeps our dependencies alive

Renovate and Dependabot reliably generate updates — and just as reliably, at some point you get merge requests that no longer go through automatically. A lockfile conflict. A breaking change. A TypeScript error. A changed CI configuration.

Muro rebases those branches, analyzes the errors, changes the code and then runs the existing checks. This gets especially handy for changes that span multiple repositories. A Playwright update affects ten websites? Then nobody has to do practically the same work ten times. Muro can find the affected merge requests, apply the change to all of them and update each branch individually. Copy-paste without the copy-paste.

He cleans up after broken pipelines

A test suite is red. A Vercel build fails. An E2E test stops working after an update. Often these aren't wildly complicated problems — but someone has to deal with them.

Muro can read logs, find the relevant spot in the codebase, try out a fix and then run the tests again. That doesn't take any tough architecture decisions off our plate — but it does clear a surprising number of small blockers.

He fixes security findings

Security tools are also excellent at producing work. A scanner like Aikido reports a problem, for example. That might lead to a change in the Dockerfile, an additional role check or an adjustment to a server action. Clearly scoped findings like these make pretty good agent tasks: problem known, goal known, code in place, checks in place. Done.

He takes on smaller features and fixes

Adding a Content Security Policy. Adjusting an SSO integration. Building a small UI extension. Correcting a configuration. Things a human might need 30 minutes for — except it's rarely really 30 minutes. First you have to find the repository, get your head back into the context, find the relevant spot and figure out how the project works. The actual code is sometimes the smallest part of the job. Muro pays far less for that context switch than we do.

He reads merge requests before we do

Muro doesn't just write code — he can also analyze existing changes. For larger dependency updates, for example, we have him figure out:

  • What changed?
  • Which breaking changes are relevant?
  • Which areas of our code could be affected?
  • How high is the risk?
  • What should we pay particular attention to in the review?

That doesn't replace a review. But it shortens the path from “What's actually going on here?” to “Okay, these are the three things I need to look at”.

He acts as a search engine for our own codebases

“Where do we actually configure that?” “Why does this project do it differently from the others?” “How does the auth flow work here?” An agent can answer questions like these differently from a regular LLM. It doesn't guess from its training data what our code probably looks like. It goes and looks. Especially during onboarding, or in projects someone hasn't worked on in a while, that's surprisingly useful.

And sometimes he works without anyone asking

Some tasks can be automated one step further. Muro can periodically check open pull requests, builds or other technical states and react to problems. That shifts the pattern from “human spots problem → human assigns agent” to “agent spots problem → agent works on problem → human gets result”. That's where “autonomous” slowly starts to become the right word.

Why these tasks in particular work well

The longer we use Muro, the clearer a pattern becomes. Right now, agents are especially strong when four things come together:

  • The problem is clearly scoped.
  • The agent has access to the context it needs and the right tools.
  • The desired result can be verified technically.
  • A mistake can be corrected without having to reinvent half the architecture.

A broken dependency merge request is almost ideal for this. There's an existing branch. There's a concrete error message. There's code. There are tests. And there's a pretty unambiguous state called green.

With questions like “How should we architect this product over the next three years?”, things get harder. There's rarely a test that tells you after five minutes: architecture decision successful. 17 tests passed. Unfortunately.

Hope is not a testing strategy

For us, this is currently one of the most important differences between “AI writes code” and “AI completes a development task”. Muro doesn't just change files and then claim to be done. He can check his work. Depending on the project, for example with:

  • TypeScript
  • ESLint
  • Unit tests
  • Integration tests
  • Playwright
  • Builds

When a check fails, the agent gets new feedback. It analyzes the error, changes the code and tries again. That sounds trivial — but it's pretty central. A language model can explain very convincingly why its code should work. The compiler is less easily impressed.

The best agent is only as good as its environment

Our experiments made something else visible, too: the model you use matters. But the environment the agent works in matters at least as much.

A well-structured repository helps. Tests help. Linting helps. Clear architecture patterns help. Good documentation helps. Machine-readable error messages help. The better a project can tell the agent whether it's on the right track, the more independently it can work in it.

The reverse is true as well. If there are no tests, Muro can't run any tests. If a business logic error still produces a technically perfectly valid build, a green build won't save you. And if the task is vague, an agent can run quite efficiently in the wrong direction at impressive speed. So agents don't make good engineering practices any less important. If anything, the opposite.

We're not trying to get rid of developers

The obvious question quickly becomes: how much software development can you automate with this? For us, a different one is more interesting right now: what work should humans actually still be doing themselves?

  • Discussing a tough architecture decision? Gladly.
  • Working with a client to figure out which problem we're actually solving? Absolutely.
  • Understanding a complex domain and designing a good system from it? Very human work.
  • Rebasing a Renovate branch for the seventeenth time and then running pnpm test? Maybe not.

That's exactly where our agents feel strongest right now. Not as mysterious digital software engineers we toss a Jira backlog at and collect a finished product from two weeks later — but as fairly independent technical colleagues for tasks that are clearly defined and easy enough to verify.

But how does it actually work?

Up to this point, we've deliberately left out one question: how does an agent get from a Slack message to an updated merge request in the first place? Because that takes quite a bit more than an LLM and a Slack bot.

For us, it includes, among other things:

  • isolated sessions per Slack thread
  • OpenCode as the execution engine
  • secured containers
  • access to GitHub and GitLab
  • terminal and codebase tools
  • a verification loop
  • identity binding between the Slack user and their permissions in connected systems

That last point becomes important fast, as soon as an agent is actually allowed to push code or change external systems. We'll get into that in part 2. There, we take a look under Muro's hood: from the Slack event through OpenCode and the isolated work environment to the question of why our agent gets exactly the same permissions as the person who gave it the task. Because once an AI agent stops just writing answers and starts changing things, the technical implementation gets pretty interesting.

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|August 2026

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

More Articles