🧠 You Don’t Need an AI Agent (Until You Do)

TL;DR — Too Long Didn’t Read

• An agent, in Anthropic's own definition, is a system where the LLM dynamically decides what steps to take and which tools to use. Everything else is a workflow — and workflows are often the right answer.

• There are two legitimate ways to build an agent on Claude: inside Claude Cowork using Skills and Plugins (no code), or with the Claude Agent SDK (Python or TypeScript).

• The Cowork path is best for knowledge work: file handling, research, reporting, multi-step tasks on your desktop. Use Plugin Create, a built-in plugin that walks you through building your own plugin through conversation.

• The SDK path is best when you need the agent to run somewhere other than your desktop — a server, a CI job, a product. Every agent gets built-in tools (Read, Write, Edit, Bash, Glob, Grep, WebSearch) plus MCP for anything custom.

• Dispatch lets you trigger a desktop agent from your phone and carry one conversation across devices. Remote Control bridges your local Claude Code session with claude.ai/code and the mobile apps. Apps render interactive charts, diagrams, and tools inside the mobile conversation.

• Schedule your agent through Cowork's scheduled tasks or Claude Code's /loop skill. Scheduled Cowork tasks only fire while your computer is awake and the app is open.

• Start small. One prompt, a narrow scope, a handful of tools. Add sub-agents, hooks, and MCP servers only when the simple version is clearly not enough.

1. What Counts as an AI Agent?

Anthropic draws a sharp line between two things people casually call "agents":

• A workflow is a system where an LLM and tools are orchestrated through predefined code paths — you know what step comes next.

• An agent is a system where the LLM dynamically directs its own process and tool use, maintaining control over how it accomplishes a task.

This distinction matters because it tells you when you even need an agent. If your process is predictable — summarize this doc, then email it — a workflow is faster, cheaper, and easier to debug. You only reach for an agent when the path through the task depends on what Claude finds along the way.

Underneath both sits the same foundation: an augmented LLM, meaning a model enhanced with retrieval, tools, and memory. Every agent you build with Claude is some combination of those three things plus a loop that decides what to do next.

The agent loop

When Claude runs as an agent, it repeats a simple cycle: read the prompt and available tools, pick a tool to call, receive the result, decide whether the task is done, and either finish or pick another tool. The Claude Agent SDK exposes this loop directly — you stream messages as Claude thinks, calls a tool, sees the output, and moves on.

Everything else in this guide — Skills, Plugins, Sub-agents, MCP, Hooks — is a way of shaping that loop.

2. The Two Paths: Cowork vs. the Agent SDK

There are two legitimate starting points depending on what you want your agent to do.

Claude Cowork is the desktop app that brings Claude's agentic capabilities to knowledge work — files on your machine, connected apps like Google Drive and Gmail, multi-step tasks that span tools. You customize it with Skills and Plugins. No code required.

The Claude Agent SDK is a Python and TypeScript library that gives you the same agent loop, tools, and context management that power Claude Code, in a form you can embed in your own application. This is the path when the agent needs to run on a server, inside another product, or anywhere other than your desktop.

A quick rule: if the person using the agent is you (or someone like you) and the work happens on a computer you own, start with Cowork. If the agent needs to run for someone else, or in the background somewhere you don't control, start with the SDK.

3. Path A — Build an Agent in Claude Cowork (No Code)

Cowork treats agent-building as a composition problem. You combine a few primitives:

• Skills are Markdown files that encode procedural knowledge — what to do, how to do it, and what good output looks like. A skill is the brain of a task.

• Connectors link Claude to external services like Google Workspace, Gmail, Slack, and many more. They supply the data and the ability to act in those services.

• Sub-agents let Claude spin up parallel workers that each handle a piece of a complex job, so it isn't reading files one at a time.

• Plugins bundle skills, connectors, sub-agents, and slash commands into a single installable package.

You don't need to learn a new format. Every component is a plain file, which is why plugins are easy to share, edit, and inspect.

Step 1: Install plugins before you build your own

Before you build anything, install a few plugins from the official marketplaces and watch what they do. This gives you working examples to copy from. Anthropic publishes two open repositories:

• anthropics/knowledge-work-plugins — intended for knowledge workers in Cowork.

• anthropics/claude-plugins-community — the community plugin marketplace, with submissions from outside Anthropic.

You can install them from inside Cowork or from claude.com/plugins. When a plugin is installed, its skills fire automatically when relevant, and its slash commands appear in your session.

Step 2: Use Plugin Create to build your own

Cowork ships with a plugin called Plugin Create, which builds a new plugin from scratch through a guided conversation. It walks you through discovery, planning, design, implementation, and packaging, and delivers a ready-to-install .plugin file at the end.

The input can be a single sentence. Claude will then ask follow-ups about your workflow, your tools, your standards, and how you handle edge cases. If you already have example deliverables you've been happy with — past reports, sample emails, a checklist — share them. Claude uses those to anchor what "good output" looks like for the new plugin.

Step 3: Test it on real work, then refine

Every source that covers Plugin Create says the same thing in different words: run the plugin on actual tasks, not a synthetic test, and update the skill files when something is off. Because the files are plain Markdown, you can have Claude edit them directly when you spot a problem.

What a Cowork agent actually looks like

A realistic first plugin has three pieces: a skill that describes the job (say, "Write a weekly sales recap"), the connectors it needs (Gmail, your CRM, Google Drive), and optionally a slash command like /recap to invoke it. When you ask Claude to run it, the skill tells Claude what to fetch, how to structure the output, and where to put it. That is an agent — Claude is choosing which connectors to hit and in what order, guided by the skill.

4. Path B — Build an Agent With the Claude Agent SDK

The Agent SDK (renamed from the Claude Code SDK to reflect it being a general-purpose agent runtime) gives you the same agent loop Claude Code runs on, in a library you can embed. It's free and open source; you pay only for the API tokens your agents consume.

Step 1: Set up

You need Python ≥ 3.10 or Node ≥ 18, and an API key from the Claude Console set as ANTHROPIC_API_KEY. Then install the SDK:

• Python: pip install claude-agent-sdk

• TypeScript: npm install @anthropic-ai/claude-agent-sdk

Create a .env file in your project with the key, and you're ready to write an agent.

Step 2: Write the agent loop

In Python, the main entry point is query(). It returns an async iterator that yields messages as Claude works — reasoning, tool calls, tool results, and the final answer.

python

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    async for message in query(
        prompt="Find and fix the bug in auth.py",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Bash"],
        ),
    ):
        print(message)

asyncio.run(main())

That's the whole loop. Claude gets the prompt, picks from the allowed tools, runs, and streams messages back until the task is done.

The TypeScript equivalent uses the same shape. There's also a newer TypeScript V2 interface in preview that exposes session.send() and session.stream() for simpler back-and-forth.

Step 3: Pick your tools deliberately

Every agent you build gets immediate access to built-in tools without any configuration: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, AskUserQuestion, Agent (for spawning sub-agents), and NotebookEdit. Allow only the tools your agent actually needs — too many tools or overlapping ones distract the model from picking efficient strategies.

By default the Agent SDK uses a minimal system prompt. If you want the full Claude Code system prompt — with coding guidelines and context loading — pass systemPrompt: { type: "preset", preset: "claude_code" } in TypeScript or the Python equivalent.

Step 4: Connect your own tools with MCP

When the built-ins aren't enough, the Model Context Protocol (MCP) is how you add your own. MCP is an open standard for connecting agents to external tools and data sources; servers can run as separate processes, over HTTP, or — for performance — directly inside your application.

To add an in-process tool in Python, wrap your function with the @tool decorator and register it with create_sdk_mcp_server. No subprocess, no IPC overhead, straight function calls. The tool's fully qualified name becomes mcp__{server_name}__{tool_name}, and you list that name in allowed_tools so it can run without a permission prompt.

Step 5: Add sub-agents for focused work

Sub-agents are separate agent instances your main agent can spawn to handle subtasks. Each runs in its own fresh conversation — the parent doesn't see the intermediate turns, only the final message comes back as a tool result. This keeps context from ballooning on complex jobs and lets you attach specialized instructions or a restricted tool set to a specific kind of work.

By default sub-agents inherit all the tools the main conversation has, including MCP tools. You can narrow that with the tools field (allowlist) or disallowedTools (denylist).

Step 6: Use hooks to keep the agent safe

Hooks are callback functions that run when the agent fires specific events — a tool is about to be called (PreToolUse), a tool returned a result (PostToolUse), a sub-agent started or finished, the session is idle. Hooks are where you block destructive shell commands, enforce file-access rules, or log every action for auditing. This is the piece most people skip and then regret.

5. Making it real: Remote Control, Dispatch, and Apps

Once you've got an agent running, the next question is where you use it from. Anthropic shipped several features in 2026 that change the answer.

Dispatch: run your desktop agent from your phone

Dispatch creates a single persistent conversation thread between the Claude mobile app and the Claude Desktop app. You message a task from your phone, and Claude figures out what kind of work it is and spins up the right session — including a desktop session to handle anything that touches your files, connectors, or installed plugins.

The setup needs the latest Claude Desktop app running on a macOS or Windows machine that's awake, plus the latest Claude mobile app. As long as the desktop machine stays on and the app stays open, you can send it work from anywhere.

The key property: it's one thread, not one session per task. Context carries across, so you can start a task on your phone, switch to the desktop, and pick it up without re-explaining anything.

Remote Control: bridge Claude Code across devices

Remote Control, launched in research preview in February 2026, bridges a local Claude Code terminal session with claude.ai/code, the Claude iOS app, and the Claude Android app. If you live in Claude Code rather than Cowork, this is the equivalent superpower — you can keep working on the same session from a phone, a browser, or the terminal.

Computer Use: let the agent drive your machine

Computer Use became available as a research preview for Pro and Max subscribers in March 2026. With it, Claude — through Cowork and Claude Code — can open files, navigate a browser, interact with GUI apps, move the mouse, and type into forms. This is what lets an agent handle work in apps that don't have connectors or APIs.

To turn it on in Cowork, enable it in Settings → Desktop app → Computer use. Treat it carefully: an agent with keyboard and mouse access can do a lot of damage by accident.

Apps: interactive output inside the conversation

Apps let the Claude mobile app render interactive content — live charts, diagrams, shareable visuals — directly inside a conversation. For an agent, this matters because the output isn't just a block of text you have to screenshot; you get something you can manipulate and share.

6. Scheduling your agent so it runs without you

Two options, depending on where your agent lives.

In Cowork, create a scheduled task by clicking + New task and typing /schedule, or by describing the schedule in the chat. Options include hourly, daily, weekly, weekdays, and manual. The important limitation: scheduled Cowork tasks only run when your computer is awake and the app is open. If it's asleep when a task was supposed to fire, Cowork skips that one and runs the task as soon as the machine wakes.

In Claude Code, the /loop skill is the fastest way to run a prompt on repeat inside an open session. You give it an interval as a bare token (30m) or a clause (every 2 hours). A recurring task expires 7 days after creation, fires one final time, and deletes itself — which puts a hard cap on how long a forgotten loop can burn tokens.

For work that should run even when your machine is off, Claude Code cloud tasks handle it server-side.

7. Best practices

The pattern every experienced builder lands on looks like this.

• Start with a plain prompt. Anthropic's own recommendation, from their "Building Effective Agents" writeup, is to start with simple prompts, evaluate them carefully, and only add agentic structure when the simple version clearly falls short. Most problems are not agent problems.

• Keep tool sets small. Too many tools distract the model. If you have ten tools and three of them overlap, consolidate. When you have a lot of tools, use namespacing — prefix by service and resource, like asana_projects_search and asana_users_search — so the model can see the boundaries.

• Write skills with examples. A skill that says "write a professional summary" is worse than one that includes a past summary you liked. Claude pattern-matches hard on examples.

• Give the agent less context, not more. A sub-agent with a fresh context window often beats a main agent carrying three hours of history. Use sub-agents for anything that can be scoped.

• Hook the dangerous tools. If your agent can run shell commands or write to disk, put a PreToolUse hook in front of those tools and validate what's being run. This is cheap insurance.

• Test the unhappy path. Most agents work fine when everything goes right. The test that matters is what happens when a tool returns an error, an API is down, or a file it needs doesn't exist.

8. Troubleshooting the mistakes people make first

• The agent keeps asking permission for every tool. You didn't pass the tool name into allowed_tools. For MCP tools, remember the fully qualified name is mcp__{server_name}__{tool_name} — use that exact string.

• The agent picks the wrong tool. Usually one of three things: tools have overlapping descriptions, there are too many tools, or the names are ambiguous. Rename, deduplicate, or narrow the tool list.

• Context explodes and responses slow down. Context does not reset between turns inside a session — the system prompt, tool definitions, conversation history, and every tool output accumulate. Move focused work into sub-agents so the parent's context stays small.

• A scheduled Cowork task never ran. Check whether the computer was awake and the app was open at the scheduled time. Cowork skips missed fires and runs once at wake-up.

• The Cowork plugin works the first time and then drifts. Skills are Markdown files — edit them. Tell Claude what was wrong, ask it to update the skill, and re-run on a real task. That's the intended loop.

• The SDK agent finishes too early. The default Agent SDK system prompt is minimal. If you're doing coding work and want the Claude Code behavior — planning, context loading, coding guidelines — switch to the claude_code preset.

• You built an agent when a workflow would do. If the path through your task is the same every time, you probably wrote more code than you needed. A prompt chain or a routing step will be faster and more reliable.

9. FAQs

Is the Claude Agent SDK different from the Claude Code SDK? It's the same thing, renamed. Anthropic renamed the Claude Code SDK to the Claude Agent SDK to signal it's a general-purpose agent runtime — not just for coding.

Do I need to pay for the SDK? No. The SDK itself is free and open source. You pay for the API tokens the agent uses, just like any other API call.

Can I build a Cowork plugin without writing any code? Yes. Plugin Create builds the whole plugin through conversation. You can read and edit the resulting Markdown files if you want, but you don't have to.

Where do plugins actually live? Plugins are installed from marketplaces — Anthropic's official marketplace, the community one, or a private enterprise marketplace your admin sets up. The open-source repos are anthropics/knowledge-work-plugins, anthropics/claude-plugins-community, and anthropics/claude-plugins-official.

What's the difference between a Skill and a Plugin? A Skill is one piece of procedural knowledge, written as Markdown. A Plugin bundles Skills together with Connectors, Sub-agents, and Slash Commands into a single installable unit.

Is MCP the only way to give Claude custom tools in the SDK? It's the recommended way. In-process MCP servers let your custom tools run as direct function calls inside your Python or TypeScript app — no separate process, no IPC overhead.

Can I run a Cowork agent on a schedule overnight? Only if the machine stays awake and the Cowork app stays open. If you need true always-on execution, use Claude Code cloud tasks instead.

What can Computer Use actually do? Open files, navigate a browser, interact with GUI apps, move the mouse, and type into forms. It's how you get an agent into apps that don't have an API or a connector.

Which path should I start with? If the agent is for you, on your machine, doing knowledge work — Cowork. If it has to run somewhere you don't control, or inside a product — the Agent SDK.