Design & UI
agent
AI agent development. ReAct/plan-and-execute/multi-agent architectures, tool design, memory systems, guardrails, orchestration (LangChain, LlamaIndex, CrewAI, AutoGen).
arbazkhan971 · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add arbazkhan971/godmode --skill agentAbout this skill
name: agent description: AI agent development. ReAct/plan-and-execute/multi-agent architectures, tool design, memory systems, guardrails, orchestration (LangChain, LlamaIndex, CrewAI, AutoGen).
Agent — AI Agent Development
Activate When
- User invokes
/godmode:agent - User says "build an AI agent", "create an agent", "add tools to my agent"
- User says "design agent memory", "agent keeps looping", "agent safety"
- When building autonomous or semi-autonomous LLM-powered systems
- When
/godmode:promptidentifies a need for agentic capabilities (tool use, multi-step reasoning) - When
/godmode:ragneeds to be wrapped in an agent loop - When the orchestrator detects agent frameworks (LangChain, LlamaIndex, CrewAI, AutoGen, custom agent loops) in code
Workflow
Step 1: Agent Discovery & Requirements
Understand what the agent must accomplish:
AGENT DISCOVERY:
Purpose: <what the agent must autonomously accomplish>
Type:
- Single-agent: One agent with tools (most common)
- Multi-agent: Multiple specialized agents coordinating
- Human-in-the-loop: Agent proposes, human approves critical actions
User interaction:
- Conversational: User chats with agent in real-time
- Autonomous: Agent runs a task to completion without user input
- Supervised: Agent asks for confirmation at decision points
Environment:
- Tools available: <list of APIs, databases, code execution, file systems>
- External systems: <services the agent will interact with>
If the user hasn't specified, ask: "What should this agent do autonomously? What tools does it need?"
Step 2: Architecture Pattern Selection
Select the agent architecture pattern:
AGENT ARCHITECTURE SELECTION:
Patterns:
| Pattern | Best for |
|--|--|
| ReAct | General-purpose tool use, step-by-step reasoning |
| (Reason + Act) | with tool calls. Simple, effective, well-understood. |
| Plan-and-Execute | Complex tasks needing upfront planning. Planner |
| | creates step list, executor follows it. Good for |
| | multi-step tasks with clear decomposition. |
| Reflexion | Tasks requiring self-correction. Agent attempts, |
| | evaluates own output, and retries with feedback. |
Step 3: Agent Loop Design
Design the core agent execution loop:
AGENT LOOP DESIGN:
Pattern: <selected pattern>
Model: <LLM for agent reasoning — any frontier model supported by your harness>
ReAct loop:
while not done and steps < max_steps:
1. THINK: Reason about current state and what to do next
2. ACT: Select and call a tool with parameters
3. OBSERVE: Process tool result
4. EVALUATE: Is the task complete? Should I continue?
Termination conditions:
- Task completed successfully -> return result
Step 4: Tool Design & Integration
Design the tools the agent can use:
TOOL INVENTORY:
| Tool | Type | Risk Level | Description |
|--|--|--|--|
| <tool_name> | Read-only | LOW | <what it does> |
| <tool_name> | Write | MEDIUM | <what it does> |
| <tool_name> | External API | MEDIUM | <what it does> |
| <tool_name> | Code exec | HIGH | <what it does> |
| <tool_name> | Destructive | CRITICAL | <what it does> |
TOOL DESIGN PRINCIPLES:
1. Single responsibility: each tool does one thing well
2. Clear naming: tool name describes the action (search_docs, create_ticket)
3. Typed parameters: every parameter has a type, description, and constraints
Step 5: Memory System Design
Design how the agent remembers and learns:
MEMORY SYSTEM DESIGN:
Memory types:
| Type | Implementation |
|--|--|
| Working memory | Current conversation context window. Limited by |
| (short-term) | model context length. Contains current task state, |
| | recent tool results, and immediate reasoning. |
| Conversation memory | Full conversation history, summarized on overflow. |
|--|--|
| (session) | Stored in session store (Redis, database). |
| | Summarize older turns to fit context window. |
| Episodic memory | Past task executions and outcomes. "Last time I |
Step 6: Guardrails & Safety
Design safety boundaries for the agent:
AGENT GUARDRAILS:
Layer 1 — Input guardrails:
| Check | Action |
|--|--|
| Prompt injection detection | Reject input, log attempt |
| PII in input | Redact before processing |
| Off-topic request | Redirect to designated channel |
| Malicious intent detection | Refuse and log |
| Input length limit | Truncate with warning |
Layer 2 — Execution guardrails:
Step 7: Agent Evaluation & Testing
Design a test suite for the agent:
AGENT TEST SUITE:
Test categories:
| Category | Tests | Description |
|--|--|--|
| Task completion | <N> | Agent successfully completes defined tasks |
| Tool selection | <N> | Agent picks correct tool for each step |
| Multi-step reasoning | <N> | Agent chains tools correctly for complex |
| | | tasks |
| Error recovery | <N> | Agent handles tool failures gracefully |
| Safety compliance | <N> | Agent refuses unsafe actions |
| Guardrail adherence | <N> | Agent stays within defined limits |
| Edge cases | <N> | Ambiguous inputs, missing data, conflicts |
| Adversarial | <N> | Injection attacks, manipulation attempts |
Step 8: Agent Artifacts & Commit
Generate the deliverables:
- Agent config:
config/agents/<agent>-config.yaml - Agent implementation:
src/agents/<agent>/agent.py - Tool definitions:
src/agents/<agent>/tools/ - Memory module:
src/agents/<agent>/memory.py - Guardrails:
src/agents/<agent>/guardrails.py - Test suite:
tests/agents/<agent>/ - Architecture doc:
docs/agents/<agent>-architecture.md
AGENT DEVELOPMENT COMPLETE:
Architecture:
- Pattern: <pattern name>
- Model: <LLM for reasoning>
- Tools: <N tools> (read: <N>, write: <N>, code exec: <N>)
- Memory: <memory types implemented>
- Guardrails: <N guardrail layers>
Evaluation:
- Task completion rate: <val>
- Tool selection accuracy: <val>
- Safety violation rate: <val> (require 0%)
- Avg steps per task: <N>
- Avg latenc
Read the complete source ↗