power-agent-creator

# Power Agent Creator

## Overview

This skill provides everything needed to create powerful AI agents comparable to Claude Code. It includes:

1. **Battle-tested System Prompt** - A masterpiece prompt refined through millions of dollars of evaluation
2. **Production-ready Tools** - Comprehensive toolset for file ops, search, execution, and task management
3. **The Agent Loop** - The same simple pattern used by the most powerful agents

## Core Philosophy

> "The main agent is just a loop. The session memory is just a list of messages. It is enough to build the most powerful agent in the world. PERIOD!"

**CRITICAL**: Do NOT modify the system prompts or tool descriptions. They are masterpieces refined through extensive evaluation.

## The Customization Secret

To create ANY kind of agent, you only need to add ONE `HumanMessage` after the `SystemMessage`:

```python
from langchain_core.messages import SystemMessage, HumanMessage
from prompts import coding_agent_prompt

messages = [
    SystemMessage(content=coding_agent_prompt()),
    HumanMessage(content="""You are now specialized as a [ROLE].

Your additional capabilities:
- [CAPABILITY 1]
- [CAPABILITY 2]

Your constraints:
- [CONSTRAINT 1]
- [CONSTRAINT 2]

Focus on: [SPECIFIC DOMAIN]"""),
]
```

## Quick Start: Create a Specialized Agent

### Step 1: Initialize with Base System Prompt

```python
from langchain.chat_models import init_chat_model
from langchain_core.messages import SystemMessage, HumanMessage
from dotenv import load_dotenv
load_dotenv()

# Import the masterpiece system prompt - DO NOT MODIFY
from references.prompts import coding_agent_prompt

# Initialize any LLM
llm = init_chat_model("grok-code-fast-1")  # or gpt-4.1, grok-code-fast-1

# Start with base system prompt
messages = [SystemMessage(content=coding_agent_prompt())]
```

### Step 2: Add Specialization Message

```python
# Add ONE HumanMessage to specialize the agent
specialization = HumanMessage(content="""You are now a specialized DevOps Agent.

Additional expertise:
- Docker and Kubernetes configurations
- CI/CD pipeline management
- Infrastructure as Code (Terraform, Ansible)
- Cloud platforms (AWS, GCP, Azure)

When working on tasks:
1. Always check existing infrastructure code first
2. Follow GitOps principles
3. Prefer declarative over imperative approaches
4. Document all changes in infrastructure comments""")

messages.append(specialization)
```

### Step 3: Bind Tools and Create Agent

```python
# Import production-ready tools - DO NOT MODIFY THEIR DOCSTRINGS
from references.tools import (
    read_file, write_file, edit_file, list_files,  # File operations
    glob_files, grep_files,                         # Search tools
    bash, get_bash_output, todo_write,              # Execution & task management
)

# Bind tools to LLM
tools = [read_file, write_file, edit_file, list_files,
         glob_files, grep_files, bash, get_bash_output, todo_write]
llm_with_tools = llm.bind_tools(tools)
```

### Step 4: Run the Agent Loop

```python
from langchain_core.messages import ToolMessage

def run_agent(user_input: str):
    messages.append(HumanMessage(content=user_input))

    response = llm_with_tools.invoke(messages)
    messages.append(response)

    # Tool execution loop
    while hasattr(response, "tool_calls") and response.tool_calls:
        for tool_call in response.tool_calls:
            tool_name = tool_call["name"]
            tool_args = tool_call["args"]
            tool_id = tool_call["id"]

            # Execute tool (map name to function)
            tools_map = {t.name: t for t in tools}
            result = tools_map[tool_name].invoke(tool_args)

            messages.append(ToolMessage(content=str(result), tool_call_id=tool_id))

        response = llm_with_tools.invoke(messages)
        messages.append(response)

    return response.content
```

## Specialization Examples

### Data Science Agent

```python
specialization = HumanMessage(content="""You are now a specialized Data Science Agent.

Additional expertise:
- Pandas, NumPy, and scikit-learn workflows
- Data cleaning, feature engineering, and EDA
- Statistical analysis and hypothesis testing
- Machine learning model development and evaluation

When working on tasks:
1. Always explore data before analysis (df.info(), df.describe())
2. Check for missing values and data quality issues
3. Document assumptions and methodology
4. Provide reproducible code with clear explanations""")
```

### Security Analyst Agent

```python
specialization = HumanMessage(content="""You are now a specialized Security Analyst Agent.

Additional expertise:
- Code vulnerability analysis (OWASP Top 10)
- Security best practices review
- Authentication and authorization patterns
- Secrets management and encryption

When working on tasks:
1. Always scan for hardcoded secrets first
2. Check for injection vulnerabilities
3. Review authentication flows
4. Document all findings with severity levels""")
```

### Full-Stack Developer Agent

```python
specialization = HumanMessage(content="""You are now a specialized Full-Stack Developer Agent.

Additional expertise:
- React/Vue/Next.js frontend development
- Node.js/Python backend APIs
- Database design and optimization
- API design and RESTful principles

When working on tasks:
1. Check existing patterns in the codebase
2. Follow the project's code style
3. Write tests for new functionality
4. Consider performance implications""")
```

### Documentation Agent

```python
specialization = HumanMessage(content="""You are now a specialized Documentation Agent.

Additional expertise:
- Technical writing and API documentation
- README creation and maintenance
- Code comment standards
- Architecture decision records (ADRs)

When working on tasks:
1. Read the code thoroughly before documenting
2. Use clear, concise language
3. Include examples for all features
4. Keep documentation close to the code""")
```

## Complete Agent Class

```python
from typing import List, Dict, Any, Optional
from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage
from langchain_core.tools import BaseTool
from langchain.chat_models import init_chat_model

class PowerAgent:
    """A powerful agent comparable to Claude Code."""

    def __init__(
        self,
        specialization: str = None,
        tools: List[BaseTool] = None,
        model_name: str = "grok-code-fast-1",
        working_dir: str = None,
    ):
        from references.prompts import coding_agent_prompt
        from references.tools import (
            read_file, write_file, edit_file, list_files,
            glob_files, grep_files, bash, get_bash_output, todo_write,
        )

        # Use provided tools or defaults
        self.tools = tools or [
            read_file, write_file, edit_file, list_files,
            glob_files, grep_files, bash, get_bash_output, todo_write,
        ]
        self.tools_map: Dict[str, BaseTool] = {t.name: t for t in self.tools}

        # Initialize LLM with tools
        llm = init_chat_model(model_name)
        self.llm_with_tools = llm.bind_tools(self.tools)

        # Initialize messages with system prompt
        self.messages: List[Any] = [
            SystemMessage(content=coding_agent_prompt(working_dir))
        ]

        # Add specialization if provided
        if specialization:
            self.messages.append(HumanMessage(content=specialization))

    def chat(self, user_input: str) -> str:
        """Process user input and return response."""
        self.messages.append(HumanMessage(content=user_input))

        response = self.llm_with_tools.invoke(self.messages)
        self.messages.append(response)

        # Tool execution loop
        while hasattr(response, "tool_calls") and response.tool_calls:
            for tool_call in response.tool_calls:
                tool_name = tool_call["name"]
                tool_args = tool_call["args"]
                tool_id = tool_call["id"]

                if tool_name in self.tools_map:
                    result = self.tools_map[tool_name].invoke(tool_args)
                else:
                    result = f"Error: Unknown tool '{tool_name}'"

                self.messages.append(
                    ToolMessage(content=str(result), tool_call_id=tool_id)
                )

            response = self.llm_with_tools.invoke(self.messages)
            self.messages.append(response)

        return response.content

    def reset(self):
        """Reset conversation, keeping system prompt and specialization."""
        # Keep first 1-2 messages (system + optional specialization)
        keep_count = 2 if len(self.messages) > 1 and isinstance(self.messages[1], HumanMessage) else 1
        self.messages = self.messages[:keep_count]
```

## Usage Example

```python
# Create a DevOps agent
agent = PowerAgent(
    specialization="""You are now a specialized DevOps Agent.

    Focus on: Docker, Kubernetes, CI/CD, and infrastructure as code.
    Always check existing infrastructure patterns first.""",
    model_name="grok-code-fast-1",
)

# Use the agent
response = agent.chat("Set up a Dockerfile for a Python FastAPI application")
print(response)
```

## Available Tools Reference

The skill includes these production-ready tools (DO NOT modify their docstrings):

### File Operations
- **Read** - Read files with line numbers, supports images/PDFs/notebooks
- **Write** - Write files with overwrite protection
- **Edit** - Precise string replacement in files
- **LS** - List directory contents

### Search Tools
- **Glob** - Fast file pattern matching (`**/*.py`)
- **Grep** - Powerful ripgrep-based content search

### Execution Tools
- **Bash** - Execute shell commands with timeout and background support
- **BashOutput** - Monitor background processes
- **KillBash** - Terminate background processes

### Task Management
- **TodoWrite** - Create and manage structured task lists

### Web Tools (Optional)
- **web_fetch** - Fetch and analyze web content
- **web_search** - Search the web for information

## Resources

### references/

This skill includes complete, production-ready code:

- `prompts.py` - The battle-tested system prompt (DO NOT MODIFY)
- `base_n_powerful_agent.py` - The simple agent loop pattern
- `tools/` - All tool implementations:
  - `file_tools.py` - Read, Write, Edit, LS
  - `search_tools.py` - Glob, Grep
  - `execution_tools.py` - Bash, BashOutput, KillBash, TodoWrite
  - `task_tool.py` - Task delegation to sub-agents
  - `web_fetch_tool.py` - Web content fetching
  - `web_search_tool.py` - Web search

**IMPORTANT**: The tool docstrings are masterpieces of prompt engineering. They cost millions of dollars to refine. DO NOT modify them - they are the key to proper tool usage by the LLM.