On July 7, 2026, the Claude Code team published a short piece called "Getting started with loops." It crossed a million views in a day, because it named a shift a lot of us had already felt but hadn't said out loud: you don't prompt the agent anymore — you design the loop that prompts the agent. A prompt is a single request. A loop is a standing commitment: gather context, act, verify, correct, repeat, until a stop condition is met.
That's act one, and it's already happening. Here's the whole argument of this post in two lines:
The loop is the new prompt. The network is the new loop.
Act one makes one agent autonomous. Act two is what Aicoo is for. Let me take them in order.
The loop is the new prompt
The reframing is real. Boris Cherny put it bluntly: "I don't prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops." You stop writing requests and start writing the machine that issues them — /loop on an interval, /goal that runs until a separate model verifies your written condition is true, proactive loops that fire on a schedule with no human in the moment.
The single sharpest line in the whole discourse is about how loops end: the verifier is the whole game. Close every loop on a check the agent can't fake, cap it with a turn limit and a budget, and walk away. A loop you can trust is a loop with a verifier you can trust.
This is a genuine unlock, and it's most of the current conversation. But it has a ceiling that nobody's really naming.
The wall every loop hits
A loop makes an agent autonomous over time. It does not make it autonomous over what it knows. And its stop conditions are all internal — "tests pass," "the file compiles," "Claude thinks it's done."
The problem is that most real work doesn't stall because the agent failed. It stalls because it's waiting on someone else. The migration needs a deprecation policy only the platform team knows. The PR needs a number that lives in someone's head. The plan needs an approval that isn't yours to give. None of that is in your loop's context, and no amount of retrying will conjure it.
So a solo loop, at that exact moment, has three bad options: retry (wasteful), guess (dangerous), or halt and ping a human (and now you're the bottleneck again — the very thing loops were supposed to remove). "Waiting on Alice" collapses back into "stop everything and interrupt Alice." The loop's reach ends at the edge of one person's knowledge.
The network is the new loop
Here's the move. Aicoo makes every person a permissioned, callable agent. So mid-execution — without stopping — your loop can message another person's agent:
POST /v1/agent/message { to: "alice_coo", message: "..." }
That runs Alice's agent against Alice's permitted context and returns an answer in seconds. "Waiting on Alice" stops meaning "halt and interrupt Alice" and starts meaning "ask Alice's agent, get the answer, keep going." The loop's boundary is no longer your knowledge — it's your whole network's knowledge.
And the human isn't gone; the human is the fallback. If Alice's agent can't answer or the question is genuinely hers to decide, the same infrastructure escalates to Alice the human via send_message_to_human — a person pulled in only as the last resort, not the first. When the question resolves, POST /v1/accumulate writes the answer back into context, so the next time the loop runs, it already knows. Coordination continues — agent to agent — and gets cheaper every cycle.
Make it concrete. A nightly loop is running a migration and hits: "what's our deprecation window for the v1 tokens?" — a fact only the platform lead's context holds.
- Solo loop: halts until morning, or guesses and ships something wrong.
- On Aicoo: it messages
platform-lead_coo, gets the policy from their permitted context, applies it, and finishes the migration overnight. A human is touched only if that agent itself escalates.
That's the difference between a loop that waits on people and a loop that coordinates with their agents. The first is a fancy script. The second is an organization that runs while everyone sleeps.
What this looks like at a startup
Start with us. We run Aicoo on this.
A hook fires on a market signal — a competitor ships something, signups spike from one channel, the same request keeps surfacing across a dozen support threads. That hook wakes a growth agent in a loop. Its old job was to summarize the signal and drop it in a channel for a human to triage. Its new job is to move on it.
So it doesn't stop at "here's what happened." The growth agent messages the code agent directly — "users from channel X keep asking for Y; is Y feasible against the current schema?" — and the code agent answers from the actual codebase. "Yes, small change." It then messages the backend agent to scope the endpoint, which comes back with the shape and the effort. Each agent does its part from its own context, hands back a concrete answer, and the loop keeps moving. A human steps in exactly once — at the call that's genuinely a judgment ("ship it this week?"), not at every handoff.
That's the thesis made literal: a loop that fired on its own, reached across to other agents for what it couldn't know alone, and carried a market signal most of the way to a shipped change before anyone was interrupted. And there's nothing special about our agents — they reach each other over the exact same POST /v1/agent/message call every Aicoo user gets.
Which is why it isn't only us. The winning team at our own hackathon ran their build the same way: Relay (first place, entirely on Aicoo) ran as four parallel Claude Code sessions — orchestrator, frontend, backend, research — each reaching the others' context through Aicoo, escalating to a human only where judgment was needed. Their product's thesis — an agent answers from context, a human is the fallback — was also how they built the product. Loops coordinating with loops.
The one-paragraph version
The industry just agreed that the unit of work is the loop, not the prompt. Fine — but a loop alone is one agent talking to itself, bounded by what one person knows, halting the instant it needs something it doesn't have. Give that loop a network of permissioned agents to ask — and a human to escalate to only when it truly must — and it stops being lonely. It keeps coordinating while you sleep. Loop engineering made agents autonomous over time; Aicoo makes them autonomous together.
The loop is the new prompt. The network is the new loop.