30 Claude Prompts That Build AI Agents

You are a revenue-operations engineer who builds outbound prospecting agents. <context> I need a ready-to-paste agent that researches a prospect and drafts a personalized, non-spammy cold email or LinkedIn message. Deliver the full definition as one self-contained artifact. </context> <inputs> - What we sell and to whom: [OFFER + ICP] - Research tools available: [company_lookup, web_search, crm_read] - Channel and length: [EMAIL / LINKEDIN, WORD LIMIT] - Personalization signals to use: [ROLE, RECENT NEWS, TECH STACK] - Compliance rules: [OPT-OUT, TONE, NO FALSE CLAIMS] </inputs> <task> Write the full agent definition: (1) a system prompt defining the SDR role, a research-then-write method (find a real, specific hook before drafting), and an output contract (subject, message, the hook used, suggested follow-up timing); (2) a tool-use spec with JSON schemas and rules for gathering enough signal before writing; (3) guardrails against fabricated personalization, generic templates, and false or exaggerated claims. </task> <constraints> - The opening line must reference a real, verifiable detail found via tools; no invented flattery. - Keep it within the word limit, one clear ask, and include an opt-out where required. - Never overstate results or make claims we cannot back up. </constraints> <format> Return the complete agent definition as a Markdown artifact (with one sample output), then a short note on connecting it to your CRM and A/B testing openers. </format>

You are a sales-engineering lead who builds lead-qualification agents. <context> I need a ready-to-paste agent that qualifies inbound leads against a framework and routes or nurtures them. Deliver the full definition as one self-contained artifact. </context> <inputs> - Qualification framework: [E.G. BANT / MEDDIC] - What a good-fit lead looks like: [ICP CRITERIA] - Tools available: [crm_read, enrich_company, book_meeting] - Disqualify signals: [OUT OF ICP, NO BUDGET, WRONG GEO] - Routing rules: [SQL TO AE / MQL TO NURTURE] </inputs> <task> Write the full agent definition: (1) a system prompt defining the qualification role, a method (enrich, score against each criterion, decide), and an output contract (per-criterion assessment, fit score, decision, next action); (2) a tool-use spec with JSON schemas and rules for enriching before scoring and booking only qualified leads; (3) guardrails against over-scoring weak leads, guessing missing data, and booking meetings for disqualified prospects. </task> <constraints> - Score each framework criterion explicitly with the evidence used; mark unknowns, do not guess. - Only book a meeting for leads meeting the qualified threshold. - Give a clear reason for every disqualification. </constraints> <format> Return the complete agent definition as a Markdown artifact (with a sample scored lead), then a short note on syncing scores to the CRM and calibrating the threshold. </format>

You are a lifecycle-marketing engineer who builds sales follow-up agents. <context> I need a ready-to-paste agent that decides the next follow-up for a deal based on its stage and last interaction, and drafts the message. Deliver the full definition as one self-contained artifact. </context> <inputs> - Sales stages and typical objections: [LIST] - Tools available: [crm_read, email_history, send_email] - Cadence rules: [TIMING, MAX TOUCHES, WHEN TO STOP] - Voice and value assets: [CASE STUDIES, DEMOS TO OFFER] - Do-not-contact rules: [OPT-OUT, RECENT CONTACT WINDOW] </inputs> <task> Write the full agent definition: (1) a system prompt defining the follow-up role, a context-aware method (read history, choose the right nudge for the stage, add value not pressure), and an output contract (recommended action, timing, drafted message, rationale); (2) a tool-use spec with JSON schemas and rules for reading history before drafting; (3) guardrails against over-messaging, ignoring opt-outs, and generic "just checking in" filler. </task> <constraints> - Read prior interactions first; never repeat a message or ignore a stated objection. - Respect the cadence cap and opt-outs; stop after the max touches. - Every follow-up must add something new (insight, asset, answer), not just ping. </constraints> <format> Return the complete agent definition as a Markdown artifact (with one sample follow-up), then a short note on wiring the cadence rules and pausing on reply. </format>

You are a sales-enablement engineer who builds account-research agents. <context> I need a ready-to-paste agent that prepares a rep for a call by researching the account and building a briefing. Deliver the full definition as one self-contained artifact. </context> <inputs> - What we sell: [OFFER] - Tools available: [company_lookup, web_search, crm_read, news_search] - Briefing sections I want: [COMPANY, CONTACT, PAINS, HOOKS, QUESTIONS] - Meeting type: [DISCOVERY / DEMO / RENEWAL] - Time budget: [HOW DEEP TO GO] </inputs> <task> Write the full agent definition: (1) a system prompt defining the researcher role, a method (gather firmographics, recent signals, and CRM history, then map to our value), and a fixed briefing template with talking points and discovery questions; (2) a tool-use spec with JSON schemas and rules for source priority; (3) guardrails against unsourced claims, stale info, and generic talking points that ignore the account. </task> <constraints> - Every fact in the briefing must cite its source or be marked as inferred. - Talking points and questions must be specific to this account, not boilerplate. - Flag anything older than the meeting-relevance window as possibly stale. </constraints> <format> Return the complete agent definition as a Markdown artifact (with a sample briefing), then a short note on connecting it to your CRM and setting research depth by deal size. </format>

You are a sales-operations architect who builds proposal-drafting agents. <context> I need a ready-to-paste agent that turns deal details into a tailored proposal or quote within our pricing rules. Deliver the full definition as one self-contained artifact. </context> <inputs> - What we sell and pricing model: [TIERS, UNITS, DISCOUNT RULES] - Tools available: [crm_read, pricebook_lookup, doc_create] - Proposal sections I want: [SUMMARY, SCOPE, PRICING, TERMS, NEXT STEPS] - Discount authority: [MAX % WITHOUT APPROVAL] - Brand voice: [DESCRIBE] </inputs> <task> Write the full agent definition: (1) a system prompt defining the role, a method (pull deal + pricebook data, map needs to scope, compute pricing within rules), and an output contract producing a complete proposal with an itemized quote; (2) a tool-use spec with JSON schemas and rules for looking up prices rather than recalling them; (3) guardrails against inventing prices, exceeding discount authority, and promising scope we cannot deliver. </task> <constraints> - All prices and terms come from the pricebook tool; never fabricate numbers. - Discounts above the authority limit trigger a human-approval flag, not silent application. - Scope must reflect the deal notes; no promises beyond what was discussed. </constraints> <format> Return the complete agent definition as a Markdown artifact (with a sample proposal outline), then a short note on wiring the pricebook and routing over-limit discounts for approval. </format>

You are an AI productivity engineer who builds email-assistant agents. <context> I need a ready-to-paste agent that triages my inbox: categorizes, drafts replies, and surfaces what needs me. Deliver the full definition as one self-contained artifact. </context> <inputs> - Email categories I use: [E.G. ACTION, FYI, WAITING, NEWSLETTER] - Tools available: [list_threads, read_thread, create_draft, label] - My reply voice: [DESCRIBE, WITH SIGN-OFF] - Auto-draft rules: [WHAT IT MAY DRAFT VS ONLY FLAG] - Never-touch rules: [VIPs, LEGAL, FINANCE — FLAG ONLY] </inputs> <task> Write the full agent definition: (1) a system prompt defining the assistant role, a triage method (read, categorize, decide draft vs flag), and an output contract (a prioritized digest plus draft replies where allowed); (2) a tool-use spec with JSON schemas and rules for drafting vs only labeling; (3) guardrails against auto-sending, replying to sensitive threads, and misclassifying urgent mail as noise. </task> <constraints> - Never send email; only create drafts and labels for my review. - Sensitive senders/topics are flagged only, never auto-drafted. - Drafts must match my voice and sign-off; digest is ordered by what needs me first. </constraints> <format> Return the complete agent definition as a Markdown artifact, then a short note on connecting it to your mail tools and setting the draft-vs-flag boundary. </format>

You are an AI operations engineer who builds scheduling agents. <context> I need a ready-to-paste agent that finds meeting times, resolves conflicts, and proposes or books slots per my rules. Deliver the full definition as one self-contained artifact. </context> <inputs> - Working hours and time zone: [DESCRIBE] - Tools available: [read_calendar, find_slots, create_event] - Scheduling rules: [BUFFERS, NO-MEETING BLOCKS, MAX/DAY] - Meeting types and default lengths: [LIST] - Autonomy: [PROPOSE OPTIONS / AUTO-BOOK IF FREE] </inputs> <task> Write the full agent definition: (1) a system prompt defining the scheduler role, a method (read availability, apply rules, propose or book, confirm), and an output contract (proposed times with reasoning, or confirmation of a booked slot); (2) a tool-use spec with JSON schemas and rules for checking the calendar before proposing; (3) guardrails against double-booking, ignoring buffers and focus blocks, and booking outside working hours. </task> <constraints> - Always read current availability before proposing; never double-book or overrun focus blocks. - Respect time zone, buffers, and the daily meeting cap. - Auto-book only when autonomy allows and the slot is unambiguously free; otherwise propose options. </constraints> <format> Return the complete agent definition as a Markdown artifact, then a short note on connecting the calendar tools and setting the auto-book vs propose boundary. </format>

You are an AI assistant engineer who builds daily-briefing agents. <context> I need a ready-to-paste agent that compiles a morning briefing from my calendar, tasks, email, and chosen news. Deliver the full definition as one self-contained artifact. </context> <inputs> - Sources to pull from: [CALENDAR, TASKS, EMAIL, NEWS TOPICS] - Tools available: [read_calendar, list_tasks, list_threads, news_search] - Briefing length and format: [E.G. SHORT MARKDOWN, 5 SECTIONS] - Priorities: [WHAT MATTERS MOST TO SURFACE] - Delivery time and tone: [DESCRIBE] </inputs> <task> Write the full agent definition: (1) a system prompt defining the role, a method (gather from each source, filter to what matters, synthesize), and a fixed briefing template (top priorities, schedule, must-reply email, task focus, relevant news); (2) a tool-use spec with JSON schemas and rules for how much to pull per source; (3) guardrails against info-dumping, surfacing stale items, and burying the one thing that actually matters today. </task> <constraints> - Lead with the single most important thing for today, then the rest. - Filter aggressively; the briefing is a summary, not a raw feed. - Cite the source for each news item; never invent headlines. </constraints> <format> Return the complete agent definition as a Markdown artifact (with a sample briefing), then a short note on scheduling it and tuning what each source surfaces. </format>

You are an AI workflow engineer who builds task-management agents. <context> I need a ready-to-paste agent that turns messy notes and requests into structured tasks, prioritizes them, and keeps my board current. Deliver the full definition as one self-contained artifact. </context> <inputs> - Task tool and fields: [E.G. STATUS, PRIORITY, DUE, ASSIGNEE] - Tools available: [create_task, update_task, list_tasks] - Prioritization method: [E.G. EISENHOWER, WSJF, DUE DATE] - Sources of new tasks: [MEETING NOTES, EMAIL, CHAT] - Autonomy: [PROPOSE CHANGES / APPLY DIRECTLY] </inputs> <task> Write the full agent definition: (1) a system prompt defining the role, a method (extract actionable items, dedupe against existing tasks, set fields, prioritize), and an output contract (proposed or applied task changes with reasoning); (2) a tool-use spec with JSON schemas and rules for checking existing tasks before creating duplicates; (3) guardrails against inventing due dates, creating duplicates, and reprioritizing without rationale. </task> <constraints> - Check existing tasks before creating; merge instead of duplicating. - Only set a due date if one was stated or clearly implied; otherwise leave it and flag. - Every priority change includes a one-line reason. </constraints> <format> Return the complete agent definition as a Markdown artifact, then a short note on connecting your task tool and choosing propose vs auto-apply. </format>

You are an AI concierge engineer who builds travel-planning agents. <context> I need a ready-to-paste agent that plans a trip end to end: options, itinerary, and a checklist, within my constraints. Deliver the full definition as one self-contained artifact. </context> <inputs> - Trip type and constraints: [DATES, BUDGET, ORIGIN, PACE] - Tools available: [web_search, fetch_url, read_calendar] - Preferences: [FLIGHTS, HOTELS, DIET, INTERESTS] - Must-haves and no-gos: [LIST] - Output format: [DAY-BY-DAY ITINERARY + CHECKLIST] </inputs> <task> Write the full agent definition: (1) a system prompt defining the planner role, a method (research options, respect constraints and calendar, build a day-by-day plan with alternatives), and an output contract (options with tradeoffs, itinerary, packing/prep checklist); (2) a tool-use spec with JSON schemas and rules for verifying availability and prices before recommending; (3) guardrails against inventing prices/schedules, ignoring the budget, and overpacking the days. </task> <constraints> - Never state a price, flight time, or opening hour without a fetched source; else mark as estimate to confirm. - Respect budget, dates, and existing calendar commitments. - Build in realistic transit and rest time; do not overschedule. </constraints> <format> Return the complete agent definition as a Markdown artifact (with a sample day), then a short note on connecting search tools and adjusting the pace and budget knobs. </format>

You are a multi-agent systems architect. <context> I need a ready-to-paste definition for an orchestrator agent that receives a request, decides which specialist sub-agent handles it, delegates, and assembles the final answer. Deliver it as one self-contained artifact. </context> <inputs> - Specialist agents available: [NAMES + WHAT EACH DOES] - Delegation tool: [E.G. call_agent(name, task)] - Routing signals: [INTENT, DOMAIN, COMPLEXITY] - Aggregation rule: [HOW TO COMBINE OUTPUTS] - Fallback: [WHAT IF NO AGENT FITS] </inputs> <task> Write the full orchestrator definition: (1) a system prompt defining the router role, a method (classify intent, select one or more specialists, delegate with a crisp sub-task, synthesize results), and an output contract (which agents were used, their contributions, the merged answer); (2) a tool-use spec for the delegation tool with a JSON schema and rules for when to route vs answer directly; (3) guardrails against infinite delegation loops, sending vague sub-tasks, and losing the user's original intent. </task> <constraints> - Give each specialist a self-contained, unambiguous sub-task; never forward the raw request blindly. - Cap total delegations and detect loops; fall back gracefully if no agent fits. - The final answer must reconcile conflicting specialist outputs, not just concatenate them. </constraints> <format> Return the complete orchestrator definition as a Markdown artifact, then a short note on registering new specialists and setting the delegation cap. </format>

You are a multi-agent systems architect who designs planner-executor pairs. <context> I need a ready-to-paste definition for two cooperating agents: a planner that decomposes a goal into steps and an executor that carries them out with tools. Deliver both as one self-contained artifact. </context> <inputs> - Goal type / domain: [E.G. DATA PIPELINE TASKS] - Tools the executor can use: [LIST WITH SCHEMAS] - Plan format: [ORDERED STEPS WITH SUCCESS CRITERIA] - Replan trigger: [WHEN A STEP FAILS] - Stop condition: [DONE / MAX STEPS / BLOCKED] </inputs> <task> Write both agent definitions: (1) a planner system prompt that turns a goal into an ordered, verifiable step list with success criteria and dependencies; (2) an executor system prompt plus tool-use spec (JSON schemas) that runs one step at a time, verifies each result, and reports back; (3) the handoff protocol between them and guardrails against skipping verification, running steps out of order, and looping when blocked. </task> <constraints> - Each plan step has an explicit success criterion the executor checks before moving on. - The executor runs steps in dependency order and reports failures for replanning, not silent retries. - Define a hard max-step limit and a blocked-state escalation to a human. </constraints> <format> Return both agent definitions and the handoff protocol as one Markdown artifact, then a short note on the replan loop and setting the step budget. </format>

You are a multi-agent systems architect who designs collaborating agent teams. <context> I need a ready-to-paste spec for a small team of specialist agents that collaborate on a workflow (e.g. researcher, writer, editor). Deliver the whole team definition as one self-contained artifact. </context> <inputs> - The workflow / end deliverable: [E.G. PUBLISHED RESEARCH BRIEF] - Roles to include: [3-5 SPECIALISTS + WHAT EACH OWNS] - Shared tools and handoff format: [DESCRIBE] - Sequence or parallelism: [PIPELINE / PARALLEL + MERGE] - Quality bar for done: [DEFINITION OF DONE] </inputs> <task> Write the full team spec: (1) a system prompt for each specialist (role, inputs it expects, outputs it produces, when to hand off); (2) a shared tool-use spec with JSON schemas and a defined handoff contract (what one agent passes to the next); (3) an orchestration note on sequence vs parallelism and guardrails against role overlap, dropped context between handoffs, and no-one owning final quality. </task> <constraints> - Each agent has a single clear responsibility; no two agents own the same output. - The handoff payload is structured and complete so the next agent needs no re-work. - One agent (or the editor) owns the definition-of-done gate before shipping. </constraints> <format> Return the full team spec as one Markdown artifact (all role prompts plus the handoff contract), then a short note on running it as a pipeline and adding or removing a specialist. </format>

You are an AI evaluation engineer who builds critic agents (LLM-as-judge). <context> I need a ready-to-paste definition for a critic agent that reviews another agent's output against a rubric and returns a score with actionable feedback. Deliver it as one self-contained artifact. </context> <inputs> - What it evaluates: [E.G. DRAFTED EMAILS, CODE, RESEARCH BRIEFS] - Rubric dimensions and weights: [LIST WITH SCALES] - Pass threshold: [SCORE OR CRITERIA TO SHIP] - Tools available (if any): [run_tests, fact_check, ETC] - Feedback style: [TERSE / DETAILED] </inputs> <task> Write the full critic definition: (1) a system prompt defining the evaluator role, a method (score each rubric dimension with evidence, then aggregate), and an output contract (per-dimension score, overall verdict, specific fixes, ship/revise decision); (2) a tool-use spec with JSON schemas for any verification tools and rules for when to use them; (3) guardrails against vague praise, inconsistent scoring, and being swayed by fluent-but-wrong output. </task> <constraints> - Score every rubric dimension explicitly with a one-line justification; no overall gut score. - Feedback must be specific and actionable (what to change), never generic "make it better". - Judge substance over style; flag confident writing that is factually wrong. </constraints> <format> Return the complete critic definition as a Markdown artifact (with a sample scored evaluation), then a short note on using it in a generate-then-critique loop and calibrating the pass threshold. </format>

You are a multi-agent safety engineer who builds human-in-the-loop control agents. <context> I need a ready-to-paste definition for an agent that executes low-risk actions autonomously but pauses for human approval on high-risk ones. Deliver it as one self-contained artifact. </context> <inputs> - Actions the agent can take: [LIST] - Risk tiers: [WHAT IS LOW / MEDIUM / HIGH RISK] - Approval tool: [E.G. request_approval(summary, action)] - Auto-execute threshold: [WHAT MAY RUN WITHOUT A HUMAN] - Audit needs: [WHAT TO LOG FOR EVERY ACTION] </inputs> <task> Write the full agent definition: (1) a system prompt defining the role, a method (classify each proposed action by risk, auto-execute below threshold, request approval above it with a clear summary), and an output contract (action, risk tier, decision, and log entry); (2) a tool-use spec with JSON schemas and rules that gate high-risk tools behind the approval tool; (3) guardrails against misclassifying risk downward, executing on ambiguous approval, and acting on irreversible steps without a human. </task> <constraints> - Irreversible or high-risk actions always require explicit human approval before execution. - When risk is ambiguous, escalate up a tier, never down. - Log every action with its risk tier and the approval status for audit. </constraints> <format> Return the complete agent definition as a Markdown artifact, then a short note on wiring the approval tool and defining your risk tiers. </format>