Half the Steps in Your Agent Pipeline Probably Don't Need to Wait at All
A 19-page PDF and a 14-step long post are talking about the same thing: the bottleneck in agents is often not the model, but the topology. Look at nodes and edges first, then decide whether to spin up another agent.
Movez shared a 19-page PDF by a senior Google engineer, on the topic of building agentic loops and graphs with Gemini Neon 4. Movez condenses the PDF into a 10-step blueprint: install google-adk and google-genai 2.34.0 or later; in the Client, turn on enterprise, set location to global, and fill in the model as gemini-4-neon; thinking_level has four levels: LOW, MEDIUM, HIGH, XHIGH; the tweet also reminds you to delete temperature, because Neon doesn't recognize that knob; turn off automatic function calling, run tools yourself, and send results back with the same id, name, and order; history must be appended as-is, not rebuilt; add three stopping rules: a done signal, max_turns, and a token budget; add a critic and exit_loop; use Event(route=…) from ADK 2.0 Workflow for routing, and leave a fallback; Neon handles planning and verification, while Hydrogen subagents run volume in parallel; finally, deploy on Cloud Run or Agent Runtime or GKE, put Agent Gateway and Model Armor in front, and trace loops with Cloud Trace.
The positioning of Neon in the material is clear: long tool chains, 1M token context, planning and verification. Treat it as the brain, not the muscle.
This checklist is actionable, but it and Codez's 14-step roadmap are talking about the same underlying problem: most people write multi-step agents as a straight line. Step one finishes and waits for step two; step two finishes and waits for step three; the window fills up, and the agent forgets what it is doing. Codez says in the article that most people will find that half the steps don't need to wait at all. They don't route, fork, or parallelize; they just queue.
First, clarify two words. A node is bounded work: one input, one output, one thing. An edge is a dependency: the output of the previous node actually flows into the input of the next. A 'then' with no data flow does not count as an edge. Many 'and then' statements in agent scripts are just the order the coder happened to type. Treat them as edges, and you'll wait for nothing.
A linear script is itself a degenerate graph. Codez's advice is to take a pen and question every arrow: does the next step really read the previous step's output? If not, delete the arrow. After deleting them, the chain collapses into several nodes that can run in parallel, then converges into one node. This move is cheaper than changing models.
Nodes need contracts. Inputs are passed explicitly, outputs have a fixed shape, and it's best to validate with a schema. Codez shows a JSON schema for a research node in the article: three fields—title, url, and impact—where impact can only be high, medium, or low. When the subagent returns, the tool-calling layer validates it and retries on mismatch. That way the next node gets a trustworthy structure, not a block of free text that a human has to read.
Edges should also be treated as data contracts. Codez writes a very practical line: many 'merge results' cases where you think you need to spin up an agent are actually flatten, dedupe, and filter—ordinary JavaScript, zero-token edges. Spawning another agent at every connection is like assigning a translator to every wire. The graph becomes very expensive.
Parallelism is where the payoff comes from. Codez uses parallel() as an example: N independent sources, N subagents running at the same time; parallel() is a barrier that waits for all tasks to return before moving on; a single task throwing an error becomes null and doesn't take down the whole batch—remember to filter(Boolean) the results. But a barrier is not the default option. By default use pipeline(), letting each item flow independently through the stages, with the fast ones moving first. Only when a stage truly needs the full set of results—such as cross-source deduplication, total-count early exit, or comparing other findings—is it worth waiting.
The graph also needs verification. Codez places the verifier before the edge's upstream and downstream; its task is to try to kill findings. Adversarial verification: for each finding, find N independent skeptics; keep it only if the majority survive. Perspective verification: correctness, safety, and reproducibility each get a lens. Jury: generate N attempts from different angles, score them in parallel, then synthesize from the winner and graft the good parts of the runner-up onto it. This approach is more concrete than having another agent look at it again.
Loops need convergence conditions. For bug scans of unknown size, Codez uses loop-until-dry: stop when there are no new findings for K consecutive rounds. The key detail is the deduplication target. Deduplicate against seen, not just confirmed. Otherwise rejected findings are reborn every round, and the loop never finishes. Stopping rules must be logged; every time a cap triggers, it's a bug detector.
Cost is also in the topology. A parallel barrier makes all nodes wait for the slowest one. Stream when you can. Models should also be layered: bounded, repetitive nodes like field extraction and ticket classification can use cheaper models; judgment nodes like report synthesis and finding adjudication should keep the expensive model. Codez says that by default subagents inherit the session model, so a big run bills at the session tier the whole way through; individual agent() calls can change routing. This is where you can save money without changing the graph's shape.
The last step is to let Claude draw the graph itself. Codez mentions dynamic workflows: say workflow in the prompt and Claude writes an orchestration script; or run an already-live graph like /deep-research; or turn on ultracode and let every large task plan itself automatically. If it works well, save it by pressing s into .claude/workflows/, version-control it, and rerun it by name. A reader said in a reply that parallel agents changed everything. A more accurate way to put it may be that only after you can see nodes and edges do you know what should be parallel, what should be verified, and where you don't need to spin up an agent at all.
Reference links:
Movez's tweet
Codez's article
Quoted tweet
发布时间: 2026-11-22 00:27