You don't have to work with one Claude at a time. Subagents, agent teams, and Cowork each let you delegate work to isolated workers running in parallel, while you stay focused on the parts that need you.
What this episode covers
A regular Claude session is one conversation. An agentic workflow is more like managing a small team: some workers do research, some do drafting, some do QA. All at once, all reporting back to you when done.
This is the advanced tier of Claude Code usage. You don't need to understand the plumbing to use these patterns, but you do need to understand when they're worth the setup cost. This episode gives you that judgment.
From easiest to most powerful. Each one is the right tool for a different job.
The non-technical delegation mode. You describe the outcome in plain language, Claude plans the steps, you approve, Claude executes. Behind the scenes it may spawn its own subagents, but you never see or manage them. Access via the Cowork tab in Claude Desktop.
A separate, isolated Claude session spawned by your current session. You're working on one thing; Claude spins up a fresh context window to handle something else in parallel. When the subagent finishes, its result comes back to the main session. You can spawn multiple subagents simultaneously.
Multiple full Claude Code sessions running in parallel, each with their own context window, connected via a shared task list. Unlike subagents which are one-shot workers, teammates can communicate peer-to-peer and self-organize around a shared goal. Each teammate gets its own isolated git worktree to prevent file conflicts.
Briefing a contractor. Isolated context. Specific job. One deliverable back.
The best mental model for a subagent: you're briefing a contractor who knows nothing about your business, nothing about what you've been working on, nothing about your current conversation. You hand them a detailed brief. They do the work. They bring you back one deliverable. Then they leave.
That isolation is the point, not a limitation. It means:
This is why the brief matters so much. The subagent can't ask clarifying questions partway through the task. It has only what you put in the prompt. A thin brief gets a thin result. A thorough brief gets a thorough result.
You don't need to configure anything special. Claude Code will use a subagent whenever a task benefits from isolation. For tasks you're consciously delegating, you can direct Claude explicitly:
Spawn a subagent to research [topic]. Give it access to web search. Ask it to return a 500-word summary with 3 key findings and sources. While it's working, let's continue here with the outline.
Claude handles the mechanics. You just describe what you want the subagent to come back with.
Give your subagents a job title, a tool list, and a personality. They'll behave consistently every time.
Beyond ad-hoc subagents, Claude Code lets you define custom subagents: pre-configured specialists with their own instructions, allowed tools, and even a model override. Define them once, invoke them by name.
Each file is a markdown document with YAML frontmatter that defines the agent's behavior:
--- name: researcher description: Use for any research task requiring web search or source gathering. Returns structured summaries with citations. model: claude-haiku-4-5 allowedTools: - WebSearch - WebFetch - Read --- You are a research specialist. When given a research topic: 1. Search for 5–8 relevant sources 2. Extract the key claims and supporting evidence 3. Return a structured summary: findings, sources, confidence Never write files. Never run commands. Read and report only.
The allowedTools field physically restricts what this agent can do. These are not just instructions it's asked to follow, but hard constraints enforced by Claude Code. A reviewer with only Read, Grep, Glob genuinely cannot write a file, even if told to.
# In any conversation, use the @ prefix: @researcher investigate the current landscape of B2B pricing models. Return your findings in the next 10 minutes. # Or ask Claude to spawn it: Use the researcher subagent to gather sources on X. I'll work on the outline while it searches.
The single most important pattern in agent delegation. Get this right and everything else follows.
Subagents start with a blank context. The only way to give them relevant background is to include it in the prompt. This is the handoff document: a structured summary of everything the subagent needs to do its job well, written as part of the brief.
Think of it as the briefing pack you'd prepare for a contractor who's never worked with you before. They know nothing about your project, your constraints, your prior decisions, or your preferences. The handoff doc is what closes that gap.
## Context You are a research subagent working on project-a, a B2B SaaS platform targeting marketing teams at 50–200 person companies. ## Your task Research pricing pages for the following 5 competitors: [list them]. For each one, document: pricing tiers, price points, feature highlights per tier, and any notable positioning language. ## Format for your output Return a markdown table followed by a 200-word synthesis of patterns you notice across competitors. ## Constraints - Focus only on publicly visible pricing pages — no sign-up required - If a competitor has no public pricing, note that and move on - Do not editorialize — document what you find, not what you think ## How to return your results Write your findings to: research/competitor-pricing-$(date +%Y-%m-%d).md Then report back to the parent with: "Competitor pricing research complete. See [path]."
For complex, multi-hour tasks, the most reliable approach is a sequential pipeline of subagents. Each one receives the prior agent's output as its handoff document.
Each phase writes its output to a file. The next phase reads that file as its input. The parent reviews and approves at each transition. This creates a reliable, inspectable pipeline where quality compounds at each stage. If one phase goes wrong, you don't lose everything.
When one sequential pipeline isn't enough and you need multiple tracks running simultaneously.
Agent Teams step up from subagents in one key way: teammates can communicate peer-to-peer and have persistent, full context windows rather than just returning a single final message. They're designed for genuinely multi-track work where different aspects of a project can advance simultaneously without blocking each other.
Agent teams are powerful. They're also expensive. A 3-teammate team uses roughly 3–4× the tokens of a single sequential session. Before spinning one up, ask: does the parallel speedup justify the cost?
Each track genuinely can't start until the others finish, and the waiting time would be longer than the token overhead. Or when three independent research tasks would take 3 hours sequentially but 1 hour in parallel.
Tasks are sequential anyway (each step requires the prior step's output). Or the overall task is short enough that a single well-prompted session handles it. Don't use a team for work one good subagent can do.
Not all agents are equal. The trust model you apply to skills applies doubly to agents.
When Claude Code runs an agentic task, it follows a permission model called deny-first with human escalation. Before any action, Claude checks in this order:
Your subagents inherit your permission configuration. If you've allowed file writes, your subagents can write files. If you've blocked reading .env, they can't read it either.
Third-party MCP servers and external agents are a different category. Anthropic does not audit, vet, or vouch for any third-party MCP server. When you install one, you're granting it the ability to act with your authority on the connected service. Apply the same trust hierarchy you use for skills (Episode 3): Anthropic-published → well-known companies → unknown sources → never-install-something-from-a-DM.
Prompt injection is the main security risk in agentic workflows. Here's how it works: you ask Claude to read a webpage, and that webpage contains hidden text, formatted to look like instructions to Claude rather than content. If Claude reads it and follows the embedded instructions, you have a problem.
Anthropic classifies prompt injection as a primary security threat for agentic systems. Their defense is a classifier that flags suspicious instruction patterns in content Claude reads. But no classifier is perfect. The human safeguard is: be skeptical of agents that are reading untrusted content and then taking actions. An agent that reads random web pages and then sends Slack messages needs more scrutiny than one that reads your own Notion pages.
Anthropic's design intention is for agent autonomy to expand as you build trust with your setup. You start with manual approvals for most actions. Over time, as you verify that a specific workflow behaves reliably, you move those actions into the allow list. The system is designed for this progression, not for maximum autonomy on day one.
Concrete, steal-these orchestration patterns for business operators.
You need to research 5 competitors before a strategy meeting. Sequential research takes 2+ hours. Parallel subagents cut it to 40 minutes.
Spawn 5 subagents simultaneously — one per competitor: [Competitor A], [Competitor B], [C], [D], [E]. Each subagent should research: pricing page, homepage messaging, recent LinkedIn posts (last 30 days), job postings. Each saves findings to research/[name]-$(date +%Y-%m-%d).md. When all 5 complete, I'll synthesize the comparison myself.
A three-phase pipeline where each phase hands off to the next. You review at each checkpoint and only approve the next phase when you're satisfied with the current one's output.
Phase 1 (researcher): Gather: top 10 questions our ICP asks about [topic]. Save to content/research.md. Report when done. [You review research.md — approve or redirect] Phase 2 (strategist): Read content/research.md. Build a content brief: recommended angle, unique point of view, outline, target keyword phrase. Save to content/brief.md. Report when done. [You review brief.md — approve or redirect] Phase 3 (copywriter): Read content/brief.md. Draft the full piece in our brand voice (see .memory/principles.md). Save to content/draft-v1.md. Report word count and confidence level.
When an operation could affect something real (posting to social media, updating a CRM, sending an email), run it in a subagent with explicit checkpoints rather than in your main session.
Spawn a subagent for the following: TASK: Draft a LinkedIn post about our pricing change announcement. Read .memory/projects/project-a.md for the announcement details. Use the linkedin-content skill. IMPORTANT: This subagent MUST NOT POST. It MUST save the draft to Drafts/linkedin-pricing-$(date +%Y-%m-%d).md and report back with the draft text for my review. I will post manually after reviewing.
A two-agent loop where one agent creates and another critiques. Useful for content where quality matters more than speed.
Step 1 — Spawn copywriter subagent: Draft a 600-word blog intro on [topic] for the project-a audience. Save to Drafts/intro-v1.md. Step 2 — Spawn reviewer subagent (read-only tools only): Read Drafts/intro-v1.md and the brand voice guide at .memory/principles.md. Review for: tone fit, clarity, hook strength, CTA effectiveness. Score each dimension 1–5. Return a structured review with specific line-level suggestions. Save review to Drafts/intro-v1-review.md. [You decide: revise, approve, or discard]
Series complete
Six episodes. One complete system. Here's what you now have.
A workspace Claude understands: memory files, project context, CLAUDE.md. The foundation everything else runs on.
Three modes, prompting patterns, context management, plan mode. How to actually use Claude day-to-day without friction.
The five-layer model. Auto-invocation. Building your own skills in 5 minutes. Anti-patterns that sink most users.
Session, desktop, and cloud schedules. Five steal-these examples. The build-once-run-forever mental model.
MCP servers. .mcp.json. Three install methods. Ten integrations. API keys. OpenRouter.
Cowork, subagents, agent teams. Handoff documents. Trust hierarchy. Four steal-these delegation patterns.
This guide is part of Vectimo Academy, a free resource from vectimo.ai. If you're looking for hands-on help applying these patterns to your business, that's what we do.
New practical guides for European SMEs adopting AI, delivered when they drop. No spam, unsubscribe anytime.
Want this done for you, not just explained? Vectimo runs the AI adoption end to end.
Work with Vectimo →