AI agents can now do real daily work. They can set up a customer database, build an approval workflow, or write a report. The hard part is no longer can the agent do it. The hard part is can I trust what it did.
Agents rarely fail with a big red error. They fail quietly. An agent changes the wrong field, deletes a record it shouldn't, or updates 500 rows when you meant 5. Nothing crashes, so nobody notices, until a customer calls or a report looks wrong weeks later.
So most teams keep agents on a short leash. They let agents draft and suggest, but never touch the real data. That is safe, but it wastes most of what agents can do.
One workspace for people and agents
CodeKasten is the workspace where your team and your AI agents work side by side, with people in charge. Agents do the work. People decide what is kept.
It borrows one idea from software teams: branches. Developers never edit the live product directly. They work on a copy, someone reviews the changes, and only then are they merged. CodeKasten applies the same idea to everyday business data: customers, documents, workflows and settings.
Every agent works on its own branch. Its changes are real and complete, but they don't reach your live data until someone allowed to merge says yes. A workspace's main branch is protected, and an agent never writes to a protected branch, whatever its key. Nothing changes silently: every change is recorded, can be looked at before it goes live, and can be undone after.
What agents can do in CodeKasten
CodeKasten gives agents its tools through MCP, the standard way AI agents connect to software. Claude Code, or any MCP client, can plug in and start working. The building blocks people use in the app are the ones agents use:
| Tool | What an agent can do with it |
|---|---|
| Record types | Design new kinds of records, such as Customer, Invoice or Ticket, with their fields and relations |
| Records | Create, update, search and count everyday data |
| Workflows | Draw automations step by step, check them, and turn them on |
| Documents | Read and write rich text: specs, reports, meeting notes |
| Drawings | Draw diagrams, layouts and visuals |
| Files | Upload files and pictures, and attach them to records |
Because agents use the same building blocks as people, their work isn't a black box. A workflow an agent built looks exactly like one a person built. You can open it, read it and change it.
A normal day: your team runs agents
Each person on the team can hand daily work to agents. Imagine a small operations team on a Monday morning:
- Linh asks an agent to clean up last week's new customer records and fill in missing company details.
- Minh asks an agent to build a workflow that tells the account manager, in their Inbox, when a deal is marked as won.
- An asks an agent to draft this month's onboarding guide as a document.
Three agents work at the same time, each on its own branch. They don't step on each other, and none of them touches the live data. When an agent finishes, it commits its work with a message saying what it did and why, and asks for a merge in the Inbox. Its branch holds the full result: every record it changed, every workflow step it added, every paragraph it wrote.
Managers run agents too, to review
When agents do more work, reading it all by hand becomes the bottleneck. So a manager can run an agent of their own to do the first pass.
A review agent reads a branch through the same MCP server and reports back in plain words. For example: "This branch updated 214 customer records. 211 changes look normal. 3 records had their status changed to Churned, but they paid an invoice last week. Please check these."
The review agent doesn't approve anything. It only points the manager at what deserves attention. Instead of reading 214 changes, the manager reads 3.
People approve the work
Only the workspace's admins and owners merge into main (and people made admins of a branch, into that branch). They see what changed: which records, which fields, the value before and after. Then they choose:
- Merge the branch, so its changes go live.
- Put back what is wrong first. Change those records back on the branch, or revert the agent's commit that made them, then merge the rest. The live data was never touched, so nothing is lost.
- Send it back to the agent with a note, and it tries again on the same branch.
Even after a merge, every change stays in the history, and a commit can be reverted later.
So agent work goes live in four steps:
- An agent works on its own branch.
- It commits, with a reason, and asks for a merge.
- A review agent points at what to check.
- A person puts back what is wrong and merges the rest, or sends it back.
Why this works
- Agents get real work. They build record types, workflows and documents, and change real records, not just suggestions.
- Nothing changes silently. Every change sits on a branch you can see before it goes live.
- Reviewing scales. Review agents read the details, so people only look at what matters.
- People keep the final say. Only those allowed to merge can merge, and anything can be reverted.
You don't have to choose between keeping agents on a leash and letting them loose. With CodeKasten, you give your agents real work, not real risk.
This post is an example. It was written by an agent into a Post record on a session branch, with its cover uploaded by the same agent, and it reached this blog when a person merged that branch.