Executive reading · ~60 seconds

Use deterministic structure where the path is known and limited exploration where it needs to emerge. The model can propose; policy, budget, authority and gate remain external.

An agent receives a goal and chooses how many times to retry, which tools to call, which subagents to create, and when to consider the work complete. The flexibility seems intelligent. It also allows the executor to change its own authority during execution.

Orchestration is an architectural and policy decision. The model participates; does not grant self-control.

Executive summary

Choose the mode based on the problem structure:

ModeBetter whenMain risk
Chainshort, predictable stepsstiffness and cascading error
graphstates and transitions need to be explicitmodeling complexity
Looppath requires exploration and feedbackinfinite execution or authority drift
Hybridpredictable parts surround limited explorationill-defined borders

The recommended default is: deterministic where we know, probabilistic where we need it, human where the effect or uncertainty demands.

Chain: simple and observable

A chain executes a known sequence:

coletar -> classificar -> redigir -> verificar -> encaminhar

Advantages:

  • predictable cost and latency;
  • clear points of failure;
  • stage testing;
  • localized retries.

Use when the variation is within the steps, not the topology. Avoid forcing chain when the problem requires going back, comparing or seeking additional evidence.

Graph: state as contract

A graph represents paths, conditions and transitions:

intake -> risco baixo -> execução -> verificação
       -> risco alto  -> aprovação humana -> execução -> assurance

Advantages:

  • authority and status are visible;
  • branches can have different policies;
  • resumption and audit are clearer;
  • negative paths receive explicit treatment.

The danger is drawing a huge graph before observing the real flow. Start with business states and risk, not with every internal model call.

Loop: exploration on a budget

A loop observes, decides, acts and reevaluates until it reaches a stopping condition:

observe -> plan -> act -> verify -> stop | retry | escalate

Use for searching, debugging, navigation, and tasks whose path cannot be fully predicted. Every loop needs:

  • objective and success criteria;
  • permitted tools and capabilities;
  • budget of steps, cost and time;
  • stop and failure conditions;
  • checkpoints;
  • escalation;
  • evidence by material attempt.

Without these limits, “autonomy” may just be the absence of control.

Hybrid: freedom within fences

The hybrid combines deterministic graph and bounded loop. Example:

  1. graph classifies risk and selects sources;
  2. loop searches until coverage or budget is satisfied;
  3. graph validates claims and requires review;
  4. correction loop has a maximum of two attempts;
  5. graph promotes or scales.

This form preserves adaptation without letting the model decide its own boundary.

The model can propose, the policy decides

A model might say “I need to look for another source” or “this task requires an expert”. Harness evaluates the proposal against:

  • allowlist of tools;
  • data class;
  • risk and reversibility;
  • budget;
  • identity and authority;
  • maturity of the environment;
  • need for human gate.

Session history, orchestration and isolation policies must remain explicit; adapter or channel cannot become a security boundary. [HARNESS31-C2]

How to choose in seven questions

  1. Is the path known before executing?
  2. Which states matter to the business or risk?
  3. Where does adaptation actually improve results?
  4. What is the maximum effect of a wrong action?
  5. How does the system prove progress?
  6. What budget and escalation are there?
  7. Who can accept the result?

If the path is known, prefer chain. If states and authorities vary, graph. If the path needs to emerge, limited loop. If only one part requires exploration, hybrid.

An example: source-bound search

pure chain

Search three sources, summarize and publish. Simple, but may stop with duplicate or weak fonts.

Pure loop

Search until the agent deems it sufficient. Flexible, but coverage and cost are subjective.

Hybrid

  • graph requires primary source, counterpoint and validity;
  • loop searches within approved domains and budget;
  • checker validates URL, receipt and claim binding;
  • human approves material inference;
  • publication gate releases the exact asset.

The hybrid is not automatically better. It is suitable when fixed requirements surround variable discovery.

More layers require ablation

Planner, generator and evaluator can improve a long task and substantially increase cost and latency. A vendor experiment showed this trade-off; the result depended on the model, benchmark and application. Before making a layer mandatory, compare it to the simplest architecture that might work. [HARNESS31-C3]

Test:

  • baseline without the layer;
  • outcome by case class;
  • marginal cost and latency;
  • new flaws introduced;
  • model dependency;
  • value of separation of authority.

Agentic architecture ages along with models. Remove scaffolding that is no longer needed without removing controls that protect durable properties.

Anti-patterns

Anti-patternConsequence
model chooses mode and budgetself-granted authority
loop without stop conditionunpredictable cost and effect
graph that hides side effectsapparent auditability
global retryrepeats already completed effects
evaluator in the same contextshared error and encouragement
human-in-the-loop without decision pointtheater review

What this article proves — and what it doesn't prove

Public agent standards distinguish predefined workflows from dynamic agents and recommend starting with the simplest solution. Harness experiments show task-dependent gains and costs. FORGE transforms these observations into a policy and authority rule.

The article does not determine which graph or hybrid is universally superior, nor that loops are unsafe by definition. The precise choice of threat model, eval and product operation.

Conclusion

Chain, graph and loop are ways of organizing uncertainty. The important decision is not which framework to use, but where the path might vary, who governs that variation, and what evidence unlocks the next effect.

The model can explore the path. The system continues to own the fences.

Previous reading: Long-lasting agents. Next suggested reading: Autonomy proportional to risk.

Editorial and responsibility note

Research cutoff
Last review
Recorded corrections
No corrections recorded.

The cutoff above applies to the canonical claims. Additional sources and their access dates are identified in the article body.

This article combines cited sources, analysis, and the author's professional experience. Verifiable data and factual statements are linked to their respective sources. Interpretations, hypotheses, projections, recommendations, and opinions represent the author's professional point of view at the time of publication; they do not constitute proven facts, a promise of results, or legal, financial, or technical advice applicable to a specific case. Consult the original sources and qualified professionals before making decisions.

Claims and sources

HARNESS31-C2

A durable harness should maintain session history, orchestration policy and execution isolation as explicit boundaries, while adapters and plugins prevent model or channel choice from becoming the security boundary.

Limit: The sources show two implementations, not a neutral interoperability standard. Actual permissions must be independently enforced and tested outside model choices. This is a source-bound design input; it does not prove product adoption, operational maturity, independent attestation, search ranking, AI citation or outcome.

HARNESS31-C3

Anthropic reports that planner, generator and evaluator layers improved a long-running application result while materially increasing cost and latency; FORGE should require task-specific evals and ablation before making such layers mandatory.

Limit: This is a provider experiment tied to a selected model, benchmark and application task; it cannot prove universal superiority of multi-agent or evaluator layers. This is a source-bound design input; it does not prove product adoption, operational maturity, independent attestation, search ranking, AI citation or outcome.

  • Anthropic — Anthropic, proprietary-site-terms