A software team in 2026 doesn't look like one from 2022. The headcount didn't change much. The roster did.
A team we'd consider typical now: three engineers, a designer, and four agents. A code reviewer, a migration specialist, a docs writer, a general-purpose planner. The engineers direct, the agents execute, and a review gate decides what ships.
That's the workflow we keep seeing in early AI-native teams: people give direction, agents do scoped work, and a human approves what actually merges.
Why now
Models got good enough. Not perfect... they misread ambiguous specs and occasionally hallucinate, but the output is more useful than not.
Context windows got large enough that an agent can hold a feature spec, the relevant files, the PR history, and the discussion thread at once. A few years ago that wasn't close.
And the plumbing got reliable. Reading and writing files, running tests, opening PRs... stable enough to trust inside an automated loop.
Below that line, AI is a writing assistant. Above it, it starts to act like a collaborator.
The routing problem
Once you have several agents, a new question shows up: which agent gets which task?
"Ask each one and pick the best" doesn't scale. What you want is a manager agent that knows which specialist fits each job. Refactor the auth middleware goes to the migration specialist. Write tests for this component goes to the QA agent. Summarize last week's PRs goes to the docs writer.
Honestly, this is still mostly unsolved. What we're building is the room where the routing happens, because the room accumulates the context that makes routing better: who handled what, what worked, what needed a human to step in.
The accountability layer
The biggest objection to all of this: if an agent breaks something, who's responsible?
The person who approved the change.
In hilos, nothing merges without human review. The agent proposes, a person approves, and the audit log records both. When something goes wrong, you can see exactly what was approved, by whom, and what the agent said it was doing.
It's also how trust gets built. You can't give an agent more autonomy until you've watched it operate in a constrained role. The review gate is where that track record lives.
The context that compounds
The agents aren't getting smarter in isolation. The context around them is growing.
A team that's worked with an agent for six months has thousands of messages, docs, and PR discussions behind it. "Fix the auth bug the way we did the last three auth refactors" is a different instruction when the agent can actually search those refactors instead of starting cold.
The room stops being a communication tool and becomes a store of context that gets more valuable with every conversation.
What teams need to get there
A shared room, where direction from people and execution from agents are visible to everyone. A review gate that keeps people in the loop without turning into a bottleneck. Context that accumulates, so each task starts warmer than the last. And clarity about who did what, because people and agents aren't interchangeable and the interface shouldn't pretend they are.
That's the product we're trying to build. For the thinking behind the interface, read where should your coding agent live?.