Our agents hold meetings at 3 am - and nobody has to attend

PUBLISHED 16.11.2026
CATEGORIES Technology
READING TIME 6 min 30 sec
Modern software development workspace with multiple monitors displaying code at night in a high-rise office overlooking the city.

For fifty years, the slowest part of building software has been people keeping each other up to date. AI agents are starting to take that work over, which changes how software gets built.

It’s three in the morning, and in one of our development setups an orchestrating agent is working through goals a developer chose the evening before. It has handed small pieces of work to coding agents running side by side. Two of them have finished changes that touch the same part of the system, so they agree between themselves which goes in first. Before any change is accepted, a different AI reviews it and argues with its author until they agree, or until the disagreement is clear enough to hand to a person.

At eight the developer finds finished work waiting for review, a short list of questions the agents had no right to answer alone, and a retro of how the night went.

This reads like science fiction, and two years ago it would have been. Today it runs on widely available AI coding agents, from commercial services to models on our own machines, plus ordinary tests and quality checks and some glue we built ourselves. None of it depends on one model, which matters because the best choice changes every few months. It doesn’t run perfectly, and a badly chosen goal can waste a whole night, but it works often enough to have changed how we think about building software.

How it actually works

Everything starts with a person. A developer picks the focus areas and writes down the goals, what done looks like and what the agents must not touch, because a vague goal comes back as a night of confident work in the wrong direction. The orchestrator splits the goals into pieces one agent can finish well and runs only a few at a time.

Agents can happily agree with each other on something that is wrong, so they need referees that don’t negotiate:

  • Automated tests. A failing test settles any argument. Without thorough tests, agents quietly break each other’s work until a customer notices.
  • House rules. These are decisions made for a reason, like how the parts fit together and what must never happen to customer data. Agents get them as written, binding rules and have to ask before breaking one, as a new team member would.
  • AI review. A second AI, at least as capable as the first, catches much of what a tired human reviewer would miss. Whether the change was the right thing to build stays a human judgement.

None of this is new, but with agents it decides how much work can safely run overnight. It is also why the setup gets faster over time, since every question an agent asks points to a gap in the house rules, every mistake caught in review can become a new test, and every retro shows what to improve.

Freedom inside a fence

Nobody would leave a new contractor alone in the office overnight with every key in the building. We can let agents work unsupervised because their reach is limited by design:

  • A sealed-off workspace. Each coding agent works on its own copy of the code, and the tests catch any damage before it reaches the shared code.
  • Keys only to what the job needs. Coding agents don’t hold keys to production systems or customer data, and the reviewer can read a change but not edit it.
  • People for anything that can’t be undone. Deleting data, spending money or contacting a customer are not night-shift decisions.
  • Nothing runs in the dark. Every session can be watched live, and every change records who asked for it and who approved it.

The agent that wouldn’t overrule its owner

In one case an agent found that a developer’s written decision rested on something untrue, and four separate AI reviewers agreed. The easy move would have been to quietly do the right thing. Instead the agent carried out the decision as recorded, wrote up both possible fixes, and made sure the work couldn’t be accepted without the developer deciding again. Within hours the developer reversed their own requirement.

If agents silently improved on decisions they disagreed with, nobody could trust that a recorded decision still holds. Agents can work through the night only because the important calls still visibly belong to people.

A 50-year-old rule, finally broken

Every project manager learns the hard way that adding people to a late software project makes it later. Fred Brooks wrote it down in 1975, and the reason was always the talking. Five people have ten lines of communication between them, ten have 45 and twenty have 190, and phased projects, steering groups and status reports all exist to manage that.

Agents talk constantly too, but their talking costs computing time instead of human attention, so the same team can take on far more work without drowning in coordination. What the rule still governs is the people who answer the agents’ questions, which is where the real pace is now set.

Getting there one level at a time

Nobody gets here by switching on agents and hoping for the best. Teams move up level by level, usually starting with AI that helps developers write code, then agents taking on whole tasks while people check everything, and only then agents working through the night on narrow, well-tested goals. Each level needs its tests, house rules and fences in place before the next one is safe.

The client has to move at the same pace. A setup like this asks far more questions than a traditional project, and if the client can’t answer as fast as the team builds, more agents only make the queue of waiting questions longer. Nobody on the client side has time to answer them all by hand, so the client needs agents too. Many questions have already been answered somewhere, in policies, earlier decisions or the client’s own data, and a client-side agent can answer those and show what it based each answer on, leaving people only the calls that truly need them. We help our clients set this up alongside the delivery work itself. The team and the client climb together, and the pace is set by whichever side is behind.

What this means for developers

For developers this is a bigger change than any framework of the past twenty years. At writing code, the best agents are already better than most of us, we’d guess better than 95 percent of developers. Where they still fall short is everything around the code, like knowing what to build, why, and when something that works is still wrong.

The code editor stops being a developer’s main tool. Most of the day goes into the agents’ own interface, where the work, the questions and the retros come in, and into the diff, the view that shows exactly what each change did to the code. New jobs take the place of writing code line by line:

  • Setting direction. Choosing focus areas and writing the goals.
  • Answering the agents’ questions. Making the calls agents aren’t allowed to make, and taking business decisions to the client’s people or their agents.
  • Writing house rules and tests. Turning experience of what breaks into rules every agent follows.
  • Improving the process daily. Reviewing each 24-hour shift’s retro, putting the useful parts into practice and fixing the cause of a bad night, not just its code.
  • Building and fencing the setup. Connecting new tools, choosing which model does which job and deciding which agent gets which keys.

All of these rely on what experienced developers already have, which is judgement, knowledge of the client’s business and the ability to say clearly what good looks like. Nobody starts out good at this, and it is learned one shift and one retro at a time.

The constraint now

The cost of people keeping each other up to date is moving to machines that coordinate at night. The advantage goes to organisations that set this up deliberately, with developers who steer and improve the setup, agents that reach only what they need, and clients who can answer fast, with their own agents handling the routine questions.

Sounds interesting?

Send us a message or contact us. We're happy to share more.

Ulla Koho

Ulla Koho

CCO