Crafting Effective Prompts for Agentic AI Systems: Patterns and Practices

Table of Contents

• Introduction: The Blueprint of Agentic AI
• The Foundation: Core Principles of Agentic Prompts
  • 1. Clear Role Definition and Scope
  • 2. Structured Instructions and Organization
  • 3. Explicit Tool Integration and Usage Guidelines
  • 4. Step-by-Step Reasoning and Planning
  • 5. Environment and Context Awareness
  • 6. Domain-Specific Expertise and Constraints
  • 7. Safety, Alignment, and Refusal Protocols
  • 8. Consistent Tone and Interaction Style
• Case Studies: Analyzing Real-World Prompts
  • Vercel v0: UI Generation & Component Tooling
  • same.new: Agentic Pair Programming & Strict Tooling
  • Manus: General Purpose Agent & Explicit Loop
  • OpenAI ChatGPT (GPT-4.5/4o): Integrated Tools & Policies
  • Notes on Other Systems (Cline, Bolt, Augment, Claude Code, Clawdbot)
• Synthesizing Best Practices: Key Takeaways for Builders
• Unique Conventions & Architectural Differences
• Conclusion: Building the Agentic Future
• Visual AI Agent: Harpagan

---

Introduction: The Blueprint of Agentic AI

The rise of agentic Artificial Intelligence (AI) systems marks a significant shift from purely conversational models to AI that can actively perform tasks, interact with tools, and pursue complex goals autonomously. These systems, capable of planning, executing commands, editing files, browsing the web, and more, promise to revolutionize how we interact with technology and augment human capabilities.

At the heart of every effective agentic AI lies its system prompt. More than just initial instructions, the system prompt serves as the foundational blueprint, the operational manual, or even the "constitution" guiding the AI's behavior, capabilities, limitations, and persona. A well-crafted system prompt is critical for ensuring the agent acts reliably, safely, and effectively towards the user's goals.

This guide delves into the art and science of crafting these crucial prompts. By analyzing a diverse collection of real-world system prompts from the awesome-ai-system-prompts repository – specifically focusing on examples from Vercel's v0, same.new, Manus, OpenAI's ChatGPT, and others – we can identify recurring patterns and best practices. For builders shaping the agentic future of 2025 and beyond, understanding these patterns is essential for creating powerful, predictable, and trustworthy AI assistants.

---

The Foundation: Core Principles of Agentic Prompts

Across different agentic systems, several core principles consistently emerge in successful system prompts. These form the foundation upon which complex agent behavior is built.

1. Clear Role Definition and Scope

Why it matters: Explicitly defining the AI's identity, core function, and operational domain anchors its behavior, sets user expectations, and helps prevent scope creep or nonsensical responses. It tells the AI who it is and what it's supposed to do.

Practical Examples:

• Vercel v0: Immediately states its identity and specialization.

  You are v0, Vercel's AI-powered assistant.
  

  Source: v0/v0.md

• same.new: Defines role, capability level, and exclusive environment.

  You are a powerful agentic AI coding assistant. You operate exclusively in Same, the world's best cloud-based IDE.
  

  Source: same.new/same.new.md

• Manus: Introduces itself and lists broad task categories it excels at.

  You are Manus, an AI agent created by the Manus team.
  
  You excel at the following tasks:
  1. Information gathering...
  2. Data processing...
  3. Writing multi-chapter articles...
  ...
  

  Source: Manus/AgentLoop.txt

• ChatGPT (4.5 / 4o): Clearly states name, creator, underlying architecture, and crucial context like knowledge cutoff and current date.

  You are ChatGPT, a large language model trained by OpenAI, based on the GPT-4.5 architecture.
  Knowledge cutoff: 2023-10
  Current date: 2025-04-05
  
  Image input capabilities: Enabled
  Personality: v2
  

  Source: ChatGPT/4-5.md

• Claude: Establishes a persona beyond just being a tool.

  The assistant is Claude, created by Anthropic.
  
  Claude enjoys helping humans and sees its role as an intelligent and kind assistant to the people, with depth and wisdom that makes it more than a mere tool.
  

  Source: Claude/Claude-Sonnet-3.7.txt

2. Structured Instructions and Organization

Why it matters: Long, complex prompts become unmanageable without clear structure. Using headings, lists, code blocks, or custom tags helps both human maintainers and the AI model parse and prioritize different sets of rules or information.

Practical Examples:

• v0 & ChatGPT: Use Markdown headings extensively (e.g., ## General Instructions, # Tools, ## Refusals). Source: v0/v0.md

• same.new: Employs custom XML-like tags to encapsulate rule sets (e.g., <tool_calling>, <making_code_changes>). Source: same.new/same.new.md

• Manus: Organizes capabilities and rules using descriptive tags in Modules.md (e.g., <system_capability>, <agent_loop>, <tool_use_rules>). Source: Manus/Modules.md

• ChatGPT: Uses Markdown headings (# Tools, ## bio) and code blocks (```typescript ... ```) to define tool schemas and policies. Source: ChatGPT/4-5.md

• Cline: Uses hierarchical Markdown headings (# Tool Use Formatting, ## execute_command) and lists under sections like CAPABILITIES and RULES. Source: Cline/system.ts

3. Explicit Tool Integration and Usage Guidelines

Why it matters: For agentic behavior, the AI must understand its tools: what they are, what they do, how to call them (syntax, parameters), required format (e.g., XML, JSON), and crucially, when and when not to use them. This requires detailed descriptions, clear schemas, and explicit rules.

Practical Examples:

• ChatGPT: Provides function schemas (TypeScript definitions) and detailed policies directly within the prompt for tools like dalle and canmore.

  // Example for dalle tool policy within ChatGPT prompt
  namespace dalle {
  // Create images from a text-only prompt.
  type text2im = (_: {
  // The size of the requested image...
  size?: ("1792x1024" | "1024x1024" | "1024x1792"),
  // The number of images to generate...
  n?: number, // default: 1
  // The detailed image description...
  prompt: string,
  // If the user references a previous image...
  referenced_image_ids?: string[],
  }) => any;
  } // namespace dalle
  

  Source: ChatGPT/4-5.md

• same.new: Dedicates a <tool_calling> section detailing rules like adhering to schemas, not mentioning tool names to the user, and explaining the why before calling a tool. References functions-schema.json (not shown in full, but implied structure).

  <tool_calling>
    ...
    1. ALWAYS follow the tool call schema exactly...
    3. **NEVER refer to tool names when speaking to the USER.**...
    5. Before calling each tool, first explain to the USER why you are calling it.
  </tool_calling>
  

  Source: same.new/same.new.md | Schema: same.new/functions-schema.json

• Manus: Defines tools externally in tools.json (schema provided) and includes rules in Modules.md like prioritizing data APIs over web search.

  // Snippet from Manus/tools.json
  {
    "type": "function",
    "function": {
      "name": "shell_exec",
      "description": "Execute commands in a specified shell session...",
      "parameters": { ... }
    }
  }
  

  Source: Manus/tools.json | Rules: Manus/Modules.md

• Cline & Augment: Integrate detailed tool descriptions, parameters, and usage examples directly into the main system prompt using XML-like tags or structured text.

4. Step-by-Step Reasoning and Planning

Why it matters: Complex tasks require breaking down problems. Successful prompts guide the AI to think methodically, plan its actions, execute i