Choose a workflow before adding a team

IDEA 1

A graph shows what depends on what

A graph makes the next step explicit. In LangGraph, nodes perform work, edges connect steps, and state carries information between them. For a school event, budget and capacity checks can read the same request independently. The final decision needs both observations. Draw that dependency before selecting a library.

State also needs an update rule. A reducer decides how a new value combines with an old one; a default overwrite can discard an earlier list of checks. Our plain-JavaScript lab appends each check to one array. When translating it to a graph, preserve both results before making the final decision.

Two checks, one decision

1. Request. Provide cost, budget, seats, and group size.
2. Independent checks. Budget passes; capacity fails. Neither result changes the other.
3. Combine. Require both checks before declaring the event ready.

The arrows represent data dependencies. This browser runs the functions synchronously; it does not demonstrate parallel speed.

Do not lose the earlier check

const earlier = [{ name: "budget", passed: true }];
const update = [{ name: "capacity", passed: false }];
const checks = [...earlier, ...update];
const ready = checks.every(check => check.passed); // false

This ordinary JavaScript illustrates an append update, not a LangGraph import. Keeping both observations lets AND enforce both requirements. Replacing the array with only the latest update would lose part of the evidence.

Think it through: The budget result is stored. A capacity node returns a new check. What must the combining step receive?

IDEA 2

Route a request to the work it needs

Routing selects a path. A request asking only for a price check needs the budget tool; a complete event review needs both tools. The router can be ordinary code when categories are explicit. A model is useful only if interpreting the request actually needs one.

Separate routing from permission. A category tells the controller which work is relevant; it does not grant the right to book or publish. Unknown categories should produce an explicit unsupported result rather than silently falling into a powerful default branch.

Choose an allowed branch

1. Read category. Inspect the structured kind field.
2. Choose branch. Budget requests skip the unrelated capacity tool.
3. Explain coverage. Return the names and outcomes of the checks actually run.

All categories and tool results in this lesson are authored fixtures.

A narrow request

if (input.kind === "budget") {
  return tools.checkBudget();
}

Explicit routing can save an unnecessary call. It is a fixed workflow because your code, rather than a model, chooses the next step.

Think it through: A request has an unknown kind. What should this router do?

IDEA 3

Decide who owns the next step

The OpenAI Agents SDK distinguishes two arrangements. With agents as tools, a manager calls specialists as bounded helpers and keeps responsibility for the final reply. With a handoff, a specialist becomes the active agent. A school-event manager combining budget and capacity reports fits the first arrangement; transferring the conversation to a dedicated help role fits the second.

These are design choices, not upgrades you must add. Our lab stays a fixed workflow: code routes requests and combines checks, with no specialist model calls. Compare any later agent version against that baseline using the same cases. More workers or agreement between models does not establish better evidence, speed, or reliability.

Helper returns, or control moves

1. Manager. The event coordinator needs two bounded reports.
2. Agents as tools. Helpers return results; the coordinator combines them and answers.
3. Handoff. Alternatively, a specialist takes over the active conversation role.
4. Baseline. First check whether ordinary routing solves the task.

This is a conceptual SDK comparison. Run the browser lab to inspect the simpler fixed workflow.

Translate the ownership, not just the name

// Conceptual patterns, not runnable SDK code:
// agents as tools: manager → helper → manager
// handoff: manager → new active specialist

The important question is who controls the next step and final response. Either arrangement still needs explicit tool permissions and evidence checks.

Think it through: One coordinator must combine two specialist reports into a final answer. Which SDK pattern expresses that ownership?

Put it into practice

Run every required check for a request, skip unrelated checks, and return the actual checked outcomes.

1. Run the starter on the event with too few seats. Notice the missing capacity check.
2. Insert the capacity branch where the TODO appears.
3. Run all three cases. Inspect why the budget-only case uses one call.
4. Change kind or a capacity value in the custom input and predict the branch before running.

Your next experiment: Try a capacity-only request, then an unknown kind. Which tools should run?

Choose a graph that follows the task's dependencies, and measure added complexity against a simple baseline.

Key terms

Dependency

A result that another step needs before it can proceed.

Routing

Selecting a relevant processing path from supported alternatives.

Orchestration

Coordinating steps, tools, or workers and combining their results.

Sources and scope

Original Stemtiq teaching, reviewed 2026-09-14. The named researchers and organizations do not endorse this course. Classroom cases are authored exercises, not published findings.