AI Prompts for AI Agents

Copy-paste prompts for planning AI agents, defining tasks, setting guardrails, creating review loops, and designing safer agent workflows.

Who These Prompts Are For

Builders, operators, founders, developers, and anyone learning how to design AI agents that behave predictably. These prompts help you plan an agent’s job, define what it’s allowed to do, build review steps, and test how it fails, before you trust it with real work.

How to Use These Prompts

Copy any prompt and paste it into ChatGPT, Claude, Gemini, or another AI tool. Replace the bracketed placeholders like [task], [tool], and [goal] with your details. Use the planning prompts first, then the guardrail and review prompts before you build anything live.

Agent Planning Prompts

Design an agent task:

Act as an AI systems designer. Help me design a single, well-scoped task for an AI agent.

The job I want the agent to do: [describe the outcome]
Who it serves: [user or team]
Tools it can access: [tools, APIs, data sources]
What "done" looks like: [success criteria]

Give me:
1. A one-sentence task definition
2. The inputs the agent needs
3. The steps it should follow, in order
4. The single output it produces
5. What it should do when an input is missing or unclear

Keep the scope narrow. Flag anything that should be a separate task.

Choose what to automate vs. keep manual:

I want to turn this process into an AI agent: [describe the process].

Split it into steps. For each step, tell me:
- Whether an agent can do it reliably today
- The risk if it gets that step wrong (low / medium / high)
- Whether it should stay manual or need human approval

Recommend the smallest version of this agent I can safely ship first.

Write an agent goal and non-goals:

Help me write a clear goal statement for an AI agent that [does X].

Output:
- Goal: one sentence describing what success means
- Non-goals: 3-5 things this agent should explicitly NOT do
- Constraints: limits on time, cost, data, or actions

Keep it specific enough that two people would build the same agent from it.

Agent Task Design Prompts

Write agent instructions:

Write the system instructions for an AI agent.

Role: [what the agent is]
Goal: [the outcome it produces]
Allowed actions: [list the tools/actions it may use]
Forbidden actions: [things it must never do]
Tone and format of output: [describe]

Write the instructions as a clear, numbered set of rules the agent follows every run. Include a rule for what to do when it lacks information, and a rule for when to stop and ask a human.

Define allowed actions:

For an AI agent that [does X] with access to [tools], list the exact actions it is allowed to take.

Format as a table:
| Action | Allowed? | Requires human approval? | Notes |

Be conservative. Anything that sends messages, spends money, deletes data, or contacts customers should require approval unless I say otherwise.

Design an agent memory plan:

Help me plan what an AI agent should remember between runs.

Agent job: [describe]
What changes between runs: [describe]

Tell me:
1. What should be stored long-term (facts, preferences, past decisions)
2. What should be forgotten after each run
3. What should never be stored (sensitive data)
4. A simple structure for storing the long-term memory

Keep it minimal — only store what changes the agent's behavior.

Agent Guardrail Prompts

Write guardrails for an agent:

Write a set of guardrails for an AI agent that [does X].

Cover:
- Inputs it should refuse or flag
- Actions that always require human approval
- Limits on cost, volume, or frequency
- What to do when a request is outside its scope
- How it should report a problem instead of guessing

Write each guardrail as a short, testable rule.

Add a “stop and ask” rule:

My AI agent sometimes guesses when it should ask. Write a clear rule that tells it when to pause and request human input.

Agent job: [describe]
Situations where guessing is dangerous: [list]

Write the rule so the agent: detects the situation, stops, explains what it needs, and waits — without taking any action.

Set human approval checkpoints:

For an agent that [does X], design the human approval checkpoints.

List each point where a human must review before the agent continues. For each checkpoint, give:
- What the human sees
- What they're approving
- The default if no response (should usually be "do nothing")

Keep checkpoints to the few moments that actually carry risk.

Human Review Prompts

Create a verifier loop:

Design a verifier step for an AI agent that produces [type of output].

The verifier should check the output against these rules: [list your quality and safety rules].

Give me:
1. A checklist the verifier runs on every output
2. A prompt I can use as the verifier
3. What happens when a check fails (revise, flag, or stop)

Write a review summary for a human:

Write a prompt that makes an AI agent summarize its own work for a human reviewer.

After completing [task], the agent should output:
- What it did, in plain language
- What it was unsure about
- Anything a human should double-check
- The one decision it would most want confirmed

Keep the summary under 150 words and scannable.

Design an escalation path:

Help me design an escalation path for an AI agent that handles [task].

Map out: when the agent handles it alone, when it asks for help, and when it hands off completely to a human. For each level, define the trigger and the action. Keep it simple enough to explain in one diagram.

Agent Evaluation Prompts

Test agent failure cases:

Act as a red-teamer. I'm building an AI agent that [does X] with access to [tools].

List 10 ways this agent could fail or be misused, including:
- Bad or malicious inputs
- Edge cases it wasn't designed for
- Actions taken on wrong data
- Loops or runaway behavior

For each, suggest one guardrail or test that would catch it.

Create a shadow mode test plan:

Help me design a shadow-mode test for an AI agent before it goes live.

Agent job: [describe]
Current manual process: [describe]

Give me:
1. What the agent should produce without taking action
2. How I compare its output to the real outcome
3. Metrics that tell me it's ready (accuracy, agreement rate, errors caught)
4. A threshold for when I can let it act on its own

Build an agent evaluation checklist:

Create an evaluation checklist for an AI agent that [does X].

Cover: accuracy, safety, cost, speed, and how it behaves on edge cases. For each item, give a simple pass/fail test I can run. End with a go/no-go recommendation format I can fill in after testing.