Wink Pings

From Queuing to Parallel: Gemini Neon's 10-Step Blueprint and Graph Engineering's 14-Step Roadmap

A Google senior engineer's 19-page PDF has been flagged by Google Drive as a violation, but Movez's 10-step distillation survives. Codez's 14 steps of graph engineering make clear the correct shape of multi-agent systems: a graph, not a chain.

A 19-page PDF and a 14-step roadmap. They come from different people and different tools, but they point to the same conclusion: the correct shape of a multi-agent system is a graph, not a straight line.

A Google senior engineer wrote that 19-page PDF, and Movez broke it down into a 10-step operational blueprint. The PDF itself is now defunct—Google Drive says it violates the Terms of Service. A netizen glanced at the first page before it was blocked and noted that the PDF's first page claims to be a synthesis of three public sources: Architecture Center, ADK docs, and the Neon developer guide. That assessment is probably correct, but the 10-step distillation has independent value.

image

Gemini Neon's 10-Step Agent Blueprint

  1. Install the stack: pip install google-adk "google-genai>=2.34.0", then genai.Client(enterprise=True, location="global"), specifying model="gemini-4-neon".
  2. Know where Neon excels: long tool-chain tasks, 1M token context, planning, and verification. Treat it as the brain, not the worker.
  3. Tune only one knob: thinking_level. LOW for routers, MEDIUM for fast tool calls, HIGH for planning, XHIGH for final checks. You can delete temperature—Neon ignores it.
  4. Write the first loop: turn off automatic function calling, manually run the tools Neon asks for, and send the results back with the same id, name, and order. Repeat until it gives an answer without needing tool calls.
  5. Don't touch the history: append Neon's responses as-is. Rebuilding the history loses thought signatures and throws MALFORMED_FUNCTION_CALL. Keep the system prompt static so caching works.
  6. Add three stop rules: a "done" signal, max_turns, and a token budget. Log every trigger—it's the best bug detector you have.
  7. Add a critic: LoopAgent(sub_agents=[critic, refiner], max_iterations=5) plus an exit_loop tool. The critic needs its own rubric and real tests, not the writer's prompt.
  8. Route with a graph: ADK 2.0 Workflow with Event(route=…) sends requests to the appropriate expert. Always add a fallback route for "none of the above."
  9. Split the work: Neon handles planning and verification, Gemini 4 Hydrogen sub-agents run the bulk in parallel, and a join node checks each result before releasing it.
  10. Deploy to Google Cloud: Cloud Run, Agent Runtime, or GKE; route traffic through Agent Gateway plus Model Armor; and trace every loop in Cloud Trace.

The implicit logic of this list: Neon is the brain and doesn't do the grunt work. Planning, verification, and convergence judgments belong to it; the bulk execution goes to cheaper sub-agents. Movez suggests feeding the PDF to Claude Code or Google Antigravity and letting them generate the code for you.

Graph Engineering in 14 Steps: From a Line to a Graph

Codez's 14-step roadmap is about Claude Code's dynamic workflows. The problem it solves is very specific: most multi-step agents end up built as a straight line. Step one, step two, step three—each step waits for the previous one. In 9 out of 10 cases, half of those steps don't need to wait at all.

Codez said in a reply: "Graph engineering is the next big thing after you know how to build loops." That line serves as the footnote to the entire methodology.

  1. Nodes are work; edges are data flow. A graph has only two kinds of things. and then is not an edge—if the next step doesn't read the previous step's output, there is no edge, and the wait is wasted.
  2. A linear script is a degenerate graph. A single chain has no redundancy: if C gets stuck, D is gone. Cut the arrows that don't carry data, and the chain collapses into a wider shape.
  3. Give nodes contracts: bounded in, validated out, one job. Use JSON schema to make sub-agents return structured data—validation happens at the tool-call layer and retries on mismatch, instead of handing you free text to parse yourself.
  4. Edges are data contracts. Doing flatten, dedupe, and filter in JS costs zero tokens. Don't spin up an agent for "merging results"—that's an edge, not a node. Save agents for places that need judgment.
  5. Fan out with parallel(). N independent nodes run at once. A thunk that throws returns null instead of dragging down the whole batch; .filter(Boolean) removes the failures. Concurrency is capped by core count, and the rest queue.
  6. Gather at a barrier. Use a barrier only where you truly need the full set: cross-source dedupe, ranking, or early exit based on the total. Just flattening a list? That's an edge—do it inline.
  7. The diamond is a work topology: split → work → merge. Fan out for breadth, reduce with code to compress, and synthesize with an agent to write the answer. When you see the diamond, the question shifts from "how do I add steps" to "where do I split and where do I merge."
  8. Do runtime routing with code. A router node produces a classification result, and if/switch decides which branch to take. Claude's judgment lives inside the node; the routing itself is code—so you never get a surprise like "Claude decided to skip the audit."
  9. Put validators on the edges. Adversarial validation: N independent skeptics refute the findings, and only the majority survivors pass. Multi-perspective validation: correctness, safety, reproducibility—different perspectives catch different failures. Judge panel: N attempts generated from different directions, scored in parallel, then the winner synthesized.
  10. Isolate nodes. In parallel(), a thunk that dies returns null, and filter(Boolean) is the isolation. For parallel file writes, use worktrees—each agent gets its own sandbox, then cleanly merges afterward.
  11. Loops must converge. loop-until-dry: stop after K consecutive rounds with no new findings. The key detail: dedupe against "everything seen," not just "confirmed." Otherwise rejected findings reappear every round, and the loop never runs dry.
  12. Tier your models. Repetitive, clearly bounded work goes to cheap models; real judgment goes to expensive ones. The agent() call can override model options. Check /model, drop fan-out to the cheap tier, and keep merge nodes at high power.
  13. Topology is cost and latency. parallel() is a barrier—it waits for the slowest node. pipeline() is streamed—each item independently goes through all stages. Default to pipeline unless a stage genuinely needs the full set.
  14. Let Claude draw the graph. Describe the goal, and Claude writes the orchestration script. Say the word "workflow," use /deep-research, or turn on ultracode. If it runs well, press s to save it to .claude/workflows/, version it, and anyone who clones the repo can launch it.

Codez gave six graphs you can copy directly:

  • Security scan: one subagent per route file, looking for missing auth checks; a validator confirms each finding before it goes into the report.
  • Citation report: /deep-research. Break down the question → search in parallel → dedupe sources → three-vote skeptic adversarial validation → synthesis.
  • File-by-file port: translate files in parallel, use the test suite as a gate, and loop back on failures. Bun ceiling—scale it to your repo.
  • Adversarial diff review: route by diff size. Small changes get a single pass; large changes get parallel audits from multiple independent perspectives, synthesized by a judge panel.
  • Scheduled ecosystem scan: check releases, blogs, and discussions in parallel, rank by impact at a barrier, and write a digest. Save it to workflows and launch by name.
  • Unknown-scale discovery: parallel finders, dedupe against seen, validate survivors, stop after two empty rounds. Good for codebases where you don't know how many bugs there are.

One Observation

What these two manuals share: the linear architecture bakes waiting into every step, while the graph architecture reserves waiting only for places that truly need the full set. Codez's article ends with a nice contrast—"A prompter asks a question. An architect draws a graph."

The problem with multi-agent systems is never "not enough steps" but "too many unnecessary dependencies." Most people will keep lining steps up in a queue out of typing habit; a few will draw the graph. The difference isn't the tools—it's whether you can see which waits are unnecessary.

发布时间: 2026-11-22 18:13