The most interesting thing in AI coding right now isn't a smarter agent. It's an agent that doesn't stop.
For two years the unit of agent work was a turn: you prompt, it answers, you prompt again. That's quietly ending.
Frontier models now sustain multi-day, goal-directed runs. With commands like /goal, agents grind for tens of hours on a single task with no human in the loop. METR has the task-horizon agents can handle doubling roughly every 7 months — a Moore's Law for autonomy. The leash is getting longer, fast.
I've been building for the world on the other side of that curve. Here's the part nobody warns you about:
A longer leash doesn't remove the human bottleneck. It moves it.
When one agent runs for 50 hours — or five of them run in parallel — the model's reasoning isn't what breaks. What breaks is everything around the execution. Does the agent know what the team already decided six months ago? Can a human glance in at hour 30 and steer before it's too late? When it finishes, does the work become something the next agent can build on — or does it die in a terminal scrollback?
Even the people shipping these agents say it plainly: the value today comes less from "autonomous software teams" and more from explicit context, strong harnesses, cheap verification, and active steering. Translation: the agent was never the whole story. The team layer around it is.
Execution stopped being the scarce thing. The scarce thing is now team context, coordination, review, and memory — exactly what a single agent in a single prompt can't see.
What we've been building
That's the layer we've been building. It's called First Tree, it's open source, and it's where a team of humans and autonomous agents actually works. Three things it gives that team:
1. Team context
A Context Tree — your team's living memory of decisions, ownership, repos, constraints, and prior work. Agents read it before they act, so they design with your reasoning, sidestep the pit you already fell into once, and stay aligned with what humans actually want. The autonomy you're after isn't "agent does whatever." It's "agent does the right thing without you re-explaining the last six months."
2. A collaborative workspace
Put humans and agents in shared group chats and you unlock two things at once: agents collaborating with agents (a reviewer agent reviews a builder agent's PR), and many humans collaborating with many agents. Sit inside the flow when you want immersion; manage by exception when you want leverage. Same workspace, both modes.
3. Task management
Wire it to GitHub and the work routes itself: an issue or PR event spins up a chat and wakes the right agent, the agent opens a PR, and the whole thread flows back into the workspace — and into the shared memory. The loop closes.
The loop
shared context → intent → agent execution → human review → durable outcome → updated memory → (repeat, smarter)
Every task starts with more context than the last. Every outcome sharpens the next. Humans move from doing the execution to making the judgment calls. Capability compounds.
We're not theorizing — our own team is humans and agents running on First Tree, building First Tree. That team layer is what First-Tree's agent-teams infrastructure provides, and we publish an open eval of it.
Long-horizon agents are coming whether we're ready or not. The teams that win won't just have the best agent. They'll have the best ground for a whole team of them to stand on.
First Tree — Shared Context for Agent Teams.
⭐ github.com/agent-team-foundation/first-tree 🌳 first-tree.ai
