Delegation Architect Decision Flow

A task-entry map for deciding what to do next. It assumes many tasks start in unfamiliar fields, so unknown-domain work is routed into controlled discovery and reversible automation.

Author: Terry (TaeGyu) Kim

Flowchart HTML | Revised 2026-07-21
Decision Proceed Controlled mode Do not delegate final action
Decision 1

Can I state "done" in one sentence?

The result must be checkable. If the goal is still vague, implementation is premature.

IFNo

The task is not ready to delegate as implementation.

THEN: run thinking or clarification first.

IFYes

The outcome is checkable enough to route.

THEN: continue to work-type classification.
Decision 2

What type of work is it right now?

Classify the current step, not the whole project forever.

IFThinking

The real question or goal is unclear.

THEN: frame the decision before delegation.

IFInvestigation

I need facts, cause, options, or examples.

THEN: delegate discovery, not implementation.

IFImplementation

I need code, a report, a workflow, or another artifact.

THEN: check domain familiarity and containment.

IFReview or Integration

I need defects found or parts combined.

THEN: use fresh review or integration proof gates.
Decision 3

Can I judge the result myself?

This determines how much authority the agent is allowed to have.

IFTier A

I understand the domain well enough to specify and judge the result.

THEN: normal delegation is allowed.

IFTier B

I can learn enough with focused investigation and review.

THEN: add a learning pass and review gate.

IFTier C

I cannot reliably judge final correctness yet.

THEN: enter unknown-domain mode.
Decision 4

If Tier C, what can be automated safely?

Unknown-domain mode is for moving carefully, not stopping.

IFSupport layer

The work maps, compares, formats, retrieves, checks consistency, drafts, or flags anomalies.

THEN: automate with assumptions exposed.

IFFinal judgment

The work approves, submits, deletes, publishes, changes shared state, or decides correctness.

THEN: keep human-controlled until validated.
Decision 5

What happens if the result is wrong?

Containment comes before implementation, not after.

IFHigh blast radius

It affects production, shared infrastructure, money, deletes, sends, publishing, or approvals.

THEN: sandbox it or keep the final step human.

IFContained

The action is reversible, isolated, or only produces a draft/artifact.

THEN: proceed to split decision.
Decision 6

How should the work be split?

Default to the simplest structure that fits. Split only when the reason is concrete.

IFOne small artifact

One domain, one output, one sitting of work.

THEN: single agent.

IFSteps depend on prior outputs

Later work needs earlier answers or artifacts.

THEN: sequential chain.

IFIndependent questions

Several investigations do not share state or edit the same artifact.

THEN: parallel investigation.

IFIndependent implementation

Multiple agents may write at once.

THEN: run the parallel implementation gate.
Decision 7

Can parallel implementation be proven safe?

This is the most expensive mistake, so the bar is high.

IFAny proof is missing

I cannot name disjoint files, isolate runtime state, test each part, or plan integration.

THEN: use sequential work, even if it feels slower.

IFAll proofs pass

Files do not overlap, runtime is isolated, tests are independent, and integration is planned.

THEN: use branches/worktrees and merge one at a time.
Decision 8

Which execution environment fits?

Choose the job shape first. Tool availability can change.

IFReasoning or draft

Framing, quick analysis, critique, or writing.

THEN: ChatGPT or Claude.

IFDeep research

Multi-source evidence needs citations and a reviewable plan.

THEN: Deep Research or a trusted-source research agent.

IFLocal files or repo

Documents, data, implementation, debugging, refactors, or tests.

THEN: Codex, Claude Code, Gemini CLI, or Copilot CLI.

IFBrowser or connected apps

Websites, private tools, or authorized workspace data are required.

THEN: use an agent with browser or app access and confirmation gates.
Decision 9

What proof gate is required?

Do not accept pasted confidence. Require proof I can inspect or rerun.

IFInvestigation

Evidence checked, source locations, confidence, unknowns.

THEN: verify claims against sources.

IFImplementation

Diff, exact files, assumptions, exact verification steps.

THEN: rerun the check myself.

IFReview

Exact defect location, severity, proven issue versus risk.

THEN: fix only grounded defects.

IFIntegration

Conflicts, resolutions, and one end-to-end check.

THEN: accept only after whole-system proof.
Decision 10

Did proof pass?

The result is not done until the proof gate survives verification.

IFPasses

Evidence is inspectable and the result matches the one-sentence goal.

THEN: integrate, capture reusable rules, finish.

IFFails once

The agent missed the gate but the structure still looks correct.

THEN: revise with a tighter spec.

IFFails twice or creates new failures

The loop is stuck, underspecified, or in the wrong mode.

THEN: restructure, use a reviewer, change tools, or take over.

Compressed Path

Define done Classify work Check familiarity Contain risk Split safely Route by capability Verify proof

Side Rules

Unknown-domain mode allows

  • Collect examples
  • Map workflows
  • Compare accepted outputs
  • Draft provisional rules
  • Flag anomalies
  • Build reversible support tools

Unknown-domain mode forbids

  • Final approval
  • Silent rule inference
  • Irreversible actions
  • Deleting, submitting, publishing
  • Treating AI guesses as domain truth

If expert answers are weak

  • Stop asking if the whole approach is valid
  • Ask about one real case
  • Ask what is wrong or dangerous
  • Ask what must always go to a human

Tool guidance checked 2026-07-21

These are routing defaults, not rankings. Plan and workspace availability vary. See the interactive version for dated official source notes and mode-specific recommendations.