How networks work

A network is staged work made visible

The simplest way to think about a network: it’s a complex task broken into stages, each with one job, where you can see what each stage produces before moving on.

That visibility is the key difference between a network and a single prompt. With a single prompt, you get the final result and have to trust it. With a network, you see the work happen.

The five things every network has

1. Inputs.

   What you give the network at the start — a goal, sources, audience, constraints. The platform validates these before the run begins.

2. Stages.

   The ordered steps. Each stage has a name (research, draft, critique, polish) and a one-sentence description of what it does.

3. Intermediate outputs.

   What each stage produces. Visible as the network runs and reviewable after.

4. The final result.

   The polished output you actually ship — usually a draft, a brief, a plan, a comparison, or a structured report.

5. The run history.

   A record of the run, with inputs, every intermediate output, and the final result. You can return to it, copy any stage's output, or rerun with adjustments.

How a network differs from a single agent

	A single agent	A network
Steps	One focused step	Several coordinated stages
Visibility	One output to review	Output for every stage
Best for	A single deliverable in a known format	Multi-stage work — research + draft + critique
Reusability	Save the brief, rerun manually	Save the network, anyone runs it
Failure mode	Refine the prompt	Identify the stage that went off track

A network is what you reach for when the task itself has shape — not just the output.

Reading intermediate outputs

The point of seeing each stage is to catch issues early. A good habit when you’re new to networks:

1. Watch the first run end to end. Read every intermediate output, even if the final result looks great. You’ll learn what each stage is actually doing.
2. On future runs, glance at the intermediate outputs only when the final result feels off. Use them to find the stage that drifted.

When an intermediate output looks wrong

• Wrong source used. The stage pulled from a different document than you expected. Adjust the input or the stage’s source rules.
• Wrong audience inferred. The stage drifted from your intended audience. Sharpen the audience in the inputs and rerun.
• Hallucinated facts. A stage produced a number, name, or date not in the sources. Tighten the stage’s instructions to “only use the attached sources” and rerun.
• Missed a key point. The stage didn’t surface something obvious. Add a constraint at the input level — “must reference the customer’s stated migration deadline.”

You don’t have to restart the whole network for any of these. Adjust the offending stage and continue.

When to let a network run vs. when to stop it

Networks have a “stop and adjust” feature for exactly this reason. A useful rule of thumb:

• Let it run when the early stages look directionally right, even if the wording isn’t perfect. Later stages will tighten the wording.
• Stop and adjust when an early stage made a directional mistake — pulled from the wrong source, named the wrong audience, missed a non-negotiable.

Stopping early is cheap. Reviewing a complete bad run and then restarting from scratch is expensive.

Rerunning with narrower instructions

Rarely does a first run land perfectly. But “rerun” almost never means “rerun the whole thing.” It usually means rerun a specific stage with a specific change.

Common narrow rerun patterns

• “Rerun the critique stage with a sharper audience: this is for our exec team, not the engineering leads.”
• “Rerun the draft stage but pull from the v2 spec, not the v1 spec.”
• “Rerun the final polish with the tone constraint applied: confident but not promotional.”

Each narrow rerun keeps the work that’s already correct. You only pay for the stage that needed to change.

Templates vs. custom networks

You’ll use both. The pattern most teams follow:

1. Start with templates. They’re tuned for common shapes of work and run reliably out of the box.
2. Run them for real tasks. Notice what they don’t do well for your specific team — wrong tone, wrong source pattern, missing a stage.
3. Customize. Either build your own network from scratch or save a customized version of the template.

By the time your team has run a template 10–20 times, you’ll know exactly what you want a custom version to do differently.

How a network uses sources

A network can pull from sources at any stage. The pattern is the same as an agent run, but multiplied:

• The whole network may have a primary source — the customer’s contract, the team’s working folder, the meeting transcript.
• Individual stages may pull from additional sources — a competitor research stage may search public docs, a critique stage may reference your style guide.

You can name sources at the network level (used by every stage) or scope them to a specific stage.

A note on speed and patience

A typical network runs in a few minutes. Some, especially research-heavy ones with many sources, can take longer. A few rules:

• Step away. You don’t have to watch the run live. Most workspaces will notify you when a run finishes.
• Run multiple in parallel. You can have several networks running at the same time on different tasks.
• Don’t restart impatiently. A network that’s still running isn’t stuck — give it a few minutes before assuming something’s wrong.

Where to go next

• Building workflows — when to turn a recurring team process into a saved network.
• Use cases — worked scenarios with stage-by-stage walkthroughs.
• FAQ — common questions about adjusting, sharing, and choosing.