Guide
Continuously improve your software with Scalpels and Solo
· Ed Grosvenor
Last updated
One of the things that can give a builder the confidence to ship fast is having a system in place that keeps everything performant and durable. This guide is a simplified version of how we manage our suite of apps and how our clients keep their apps healthy. It's a simple continuous improvement loop that runs completely autonomously, powered by Scalpels and Solo from Aaron Francis.
Here's the elevator pitch for the loop:
- Every hour, an agent reads what your apps did since the last time it looked: slow requests and new exceptions from Hone, errors and unusual log volume from Wake, and browser sessions that hit an error from Reel.
- It decides what is new, what is getting worse, and what is just noise.
- For each real problem, it files a Solo todo and a GitHub issue, then starts a second agent to investigate it.
- The investigator finds the cause, reproduces it, and either reports back or fixes it, depending on how much you trust it with that project.
The loop is just a python script that runs once an hour, sending a prompt to the conductor agent in Solo. Solo's MCP lets that conductor spawn additional agents, so each finding can be handed off to a fresh agent, leaving the conductor to just do simple classification and triage of the findings in the data.
How the pieces fit
| Piece | Job in the loop |
|---|---|
| Hone | Performance and exceptions. What got slower, what started failing, and which deploy came before it. |
| Wake | Logs from every app in one place. Error lines, and changes in how much each app is logging. |
| Reel | Session replay. What a real person was doing when a request failed, so an investigator can see the bug instead of guessing at it. |
| Scalpels MCP | One connection to all three, for every team you belong to. The agent asks Scalpels, and Scalpels relays the question to the app running in your own infrastructure. |
| Solo | Where the agents live. Solo runs the conductor and the investigators, holds the conductor's notes and tracks the todos. |
| cron | The clock. A small script, run every hour, makes sure the conductor is there and tells it to start. |
| GitHub | The permanent record. Issues for every problem, and pull requests for every fix. |
Hone, Reel and Wake are all read-only to the agent in this setup. None of them has a tool that "fixes" anything. The agent's job is to notice, explain and propose. What happens after that is up to you, project by project. The remediation page is about how to decide.
The parts of this guide
- What you need: the apps, the tokens, and a computer that stays awake.
- The ledger: the one scratchpad that remembers when the last run was and what it has already seen.
- The conductor: the standing Solo agent, the script that rings it every hour, and its standing orders.
- The sweep: exactly what to ask each app, and how to turn "since the last run" into arguments each one accepts.
- Investigations: turning a finding into a todo, an issue and an investigator, without ever chasing the same problem twice.
- Remediation: how far an investigator should go on its own, and the questions that decide it.
Read them in order the first time. The conductor's orders refer to the ledger, the sweep and the investigation rules, and it works best when you have tuned all three for your own apps.
The code that goes with this guide, including the script cron runs and every file of instructions the agents read, is in artisan-build/scalpels-guides on the continuously-improve-your-software branch.
Changelog
- Published.
