Try2learn

Courses · A practical starting point

AI agent orchestration

Plan a request. Assign the work. Accept it with evidence.

10 sections + 3 real cases + your first setup

Follow the video order and build a small coordinator-and-worker workflow for your own project. Work through the setup at your own pace.

Start with examples Your first setup

The full explanation lives in the Agent orchestration lesson (Turkish). This course gives you short section summaries, copyable examples and a setup checklist. The lesson links below open Turkish content.

Sections in video order

  1. Opening scene

    An agent says the task is done. Learn why that claim needs evidence.

    Read the lesson: Opening scene (Turkish)
  2. The problem

    Separate repeated instructions, growing context and premature handoffs.

    Read the lesson: The problem (Turkish)
  3. Think like a small company

    Give coordination, execution and review to clearly defined roles.

    Read the lesson: Think like a small company (Turkish)
  4. The chain

    Follow a request through planning, assignment, execution, review and acceptance.

    Read the lesson: The chain (Turkish)
  5. A plan that fits the task

    Keep small plans short. Stop assignments that have no usable plan.

    Read the lesson: A plan that fits the task (Turkish)
  6. The worker does not approve its own work

    Ask a separate reviewer to check the same result and evidence.

    Read the lesson: The worker does not approve its own work (Turkish)
  7. Modes and cost

    Match the model and working mode to the task, then judge the result.

    Read the lesson: Modes and cost (Turkish)
  8. Memory and records

    Keep stable rules, current requests and the location of each part separate.

    Read the lesson: Memory and records (Turkish)
  9. Your first setup

    Build a small workflow around a practice project and its first delivery.

    Read the lesson: Your first setup (Turkish)
  10. Closing the loop

    Trace one request from its initial record to an accepted result, and improve your setup as you go.

    Read the lesson: Closing the loop (Turkish)

Three real cases

Copyable examples

Practice task: clarify an ambiguous sentence on a contact page. Replace the file and task names with ones from your own practice project. Review and merge existing instruction or settings files rather than overwriting them.

order.json

{
  "id": "contact-copy",
  "PLAN": {
    "what": "Clarify the ambiguous sentence on the contact page.",
    "scope": "Only contact.html; no behavior or publishing changes.",
    "check": "Compare the before and after text and check the visible page."
  },
  "acceptance": [
    "The intended meaning is preserved.",
    "Only the allowed file changes.",
    "The visible text and delivery describe the same change."
  ],
  "delivery": "ORDER-DELIVERY contact-copy | READY | file, check, actual result, limitations"
}

The PLAN defines the task, its scope and how to check the result. The acceptance criteria turn “done” into a measurable outcome. The order ID links an assignment to its delivery.

plan_gate.py

import json
import sys
from pathlib import Path

try:
    order = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
    plan = order.get("PLAN", {})
    for field in ("what", "scope", "check"):
        if not isinstance(plan.get(field), str) or not plan[field].strip():
            raise ValueError("Missing PLAN field: " + field)
    if not isinstance(order.get("id"), str) or not order["id"].strip():
        raise ValueError("An order ID is required")
    criteria = order.get("acceptance")
    if not isinstance(criteria, list) or not criteria or not all(
        isinstance(item, str) and item.strip() for item in criteria
    ):
        raise ValueError("Acceptance criteria must be a nonempty list")
except (OSError, ValueError, TypeError, AttributeError, IndexError) as error:
    print("PLAN-REJECT: " + str(error), file=sys.stderr)
    raise SystemExit(2)
print("PLAN-PASS: " + order["id"])

.claude/settings.json

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Agent",
        "hooks": [
          {
            "type": "command",
            "command": "python3 \"$CLAUDE_PROJECT_DIR/plan_gate.py\" \"$CLAUDE_PROJECT_DIR/order.json\""
          }
        ]
      }
    ]
  }
}

Try the gate

python3 plan_gate.py order.json

Project rules: CLAUDE.md

# A small project workflow
The main session coordinates: examine the request, then write a PLAN and acceptance criteria.
Do not call a subagent before planning the order.
The worker changes only allowed files and cannot accept its own result.
The reviewer checks the same change and evidence without editing files.
A delivery is READY. Acceptance and publishing decisions belong to the user.

Worker: .claude/agents/worker.md

---
name: worker
description: Prepares the small text change specified by an order.
tools: Read, Grep, Glob, Edit, Write, Bash
isolation: worktree
---
Acknowledge the order ID with ORDER-RECEIVED.
Read the goal and scope. Stop and ask if they are unclear.
Make a small change that preserves the meaning, only in the allowed file.
Return the working-copy location, diff, checks and actual result to the coordinator.
Mark ORDER-DELIVERY as READY. Never mark your own result ACCEPTED.

Reviewer: .claude/agents/reviewer.md

---
name: reviewer
description: Compares a ready delivery with its acceptance criteria.
tools: Read, Grep, Glob
---
Read the before-and-after text and evidence for the same change.
Check the intended meaning, allowed files and visible result.
Do not claim to have run a check you did not run.
Report findings and missing evidence to the coordinator. Do not edit files.
Leave final acceptance to the user.

Delivery and acceptance

ORDER-RECEIVED contact-copy
ORDER-DELIVERY contact-copy | READY
File: contact.html
Check: before-and-after text and the visible page
Result: describe what you actually observed
Missing: state any gaps

REVIEW contact-copy | NO FINDINGS or FINDINGS
Basis: the same diff and evidence

ACCEPTED contact-copy | user decision
Publishing: no separate decision yet

Record the result you actually observed. Copying the sample delivery line does not prove that a task succeeded.

Ask the coordinator

As coordinator, read CLAUDE.md and order.json.
Check the PLAN and acceptance criteria. Assign only this order to the worker subagent.
Obtain its working copy, diff and actual evidence.
Give that same diff and evidence explicitly to the reviewer subagent.
Bring the findings to me. Do not treat a ready delivery as accepted.
Leave acceptance and publishing decisions to me.

Who does what?

RoleResponsibilityHandoff
CoordinatorWrites the plan, scope and acceptance criteria.An explicit assignment.
WorkerMakes the allowed change and records the actual checks.A result marked READY.
ReviewerChecks that result and its evidence independently.Findings for the coordinator.
YouDecide whether the result meets the request.Acceptance or a specific revision.

This plan gate is a custom script, not a built-in Claude Code feature. The hook checks that the fixed order.json has a usable PLAN before an Agent call. It does not prove the plan is good or cover every tool. Exit code 2 blocks the call; test both a valid and an incomplete assignment. Configure it only in a practice project after checking the current tool documentation.

READY means the worker has handed over its result. ACCEPTED is a separate decision after review. One does not imply the other.

If newly added subagents do not appear, restart your Claude Code session. For the full setup, see Build it yourself in the lesson (Turkish).

Your first setup

Prerequisites: a small practice project with Git, a working python3 command and Claude Code. Follow the setup at your own pace.

  1. Pick a practice project

    What you do: Choose one local project and one sentence you can check yourself.

    What you see: You have a small task with a clear before-and-after result.

  2. Write the project rules

    What you do: Adapt the CLAUDE.md example and the worker and reviewer files. Merge any existing rules.

    What you see: Each role has a scope and a delivery format.

  3. Create the assignment

    What you do: Save order.json with a PLAN, allowed files and acceptance criteria.

    What you see: A reader can tell what is allowed and what counts as success.

  4. Try the plan gate

    What you do: Save plan_gate.py and the hook configuration. Run the script with a complete order, then remove a PLAN field and run it again.

    What you see: The complete order passes with code 0; the incomplete one is rejected with code 2.

  5. Run one task and review it

    What you do: Ask the worker to change the sentence. Give the delivered result and evidence to the reviewer.

    What you see: The worker reports READY; a separate review checks the visible text and the scope.

  6. Make the acceptance decision

    What you do: Compare the request, changed page and review findings. Accept the result or ask for one concrete revision.

    What you see: Your record distinguishes delivered work from accepted work.

These steps are a starting plan, not a time guarantee. Take longer when the task needs it.

Sources and next steps

Full orchestration lesson (Turkish) · Official hook reference · Official subagent guide

Last verified: .

Use Support to keep local notes and tasks. Export them before clearing browser storage.

Try2learn is an independent learning site, unaffiliated with Anthropic, OpenAI or Google. Product names belong to their owners.