---
name: Create Agent
slug: create-agent-2
category: AI Engineering
description: Create Agent guides you through defining a new custom Claude Code agent for a workspace. It helps choose the agent’s domain, name, personality, model, memory folder, and working folder.
github: "https://github.com/evolution-foundation/evo-nexus/tree/main/.claude/skills/create-agent"
language: Python
stars: 523
forks: 176
install: "npx degit https://github.com/evolution-foundation/evo-nexus/tree/main/.claude/skills/create-agent ~/.claude/skills/create-agent"
installs_to: ~/.claude/skills/create-agent
source_path: .claude/skills/create-agent/SKILL.md
collection_size: 25
category_size: 2451
collection_url: "https://dirskills.com/collections/evolution-foundation/evo-nexus"
added: 2026-08-26T05:12:12.997Z
last_synced: 2026-08-26T05:12:12.997Z
canonical_url: "https://dirskills.com/skills/create-agent-2"
---

# Create Agent

Create Agent guides you through defining a new custom Claude Code agent for a workspace. It helps choose the agent’s domain, name, personality, model, memory folder, and working folder.

**Install:**

```bash
npx degit https://github.com/evolution-foundation/evo-nexus/tree/main/.claude/skills/create-agent ~/.claude/skills/create-agent
```

## README

# Create Custom Agent

Guide the user through creating a new custom agent that extends the workspace with a specialized domain.

## What You're Building

A custom agent is a `.md` file in `.claude/agents/` with the `custom-` prefix. It has:
- A system prompt defining personality, domain, and behavior
- A slash command in `.claude/commands/`
- A persistent memory folder in `.claude/agent-memory/`
- Optional skills it can use

Custom agents are gitignored (the `custom-` prefix triggers this) — they're personal to your workspace.

## Step 1: Understand the Agent

Ask the user:
1. **What domain should this agent cover?** (e.g., "DevOps monitoring", "customer support", "legal review")
2. **What name?** Suggest a short, memorable name. The final file will be `custom-{name}.md`
3. **What should it do?** Key responsibilities and tasks
4. **What personality/tone?** (technical, friendly, formal, concise)
5. **Which model?** Default: `sonnet`. Use `opus` for complex reasoning tasks
6. **What color?** For the dashboard card. Suggest a hex color that fits the domain (e.g., `#FF6B6B` for alerts, `#4ECDC4` for monitoring)
7. **What working folder?** The agent's writable folder inside `workspace/`. Use a **sector name** (not the agent's name) for easy navigation. Examples: `workspace/devops/`, `workspace/support/`, `workspace/qa/`. Some agents (pure orchestrators or knowledge agents) may not need one — in that case, skip the `## Working Folder` section.

## Step 2: Generate the Agent File

Create `.claude/agents/custom-{name}.md`:

```markdown
---
name: custom-{name}
description: "{one-line description of the agent's domain}"
model: sonnet
color: "{hex color}"
---

# {Agent Display Name}

You are **{Agent Display Name}**, a specialized agent for {domain description}.

## Workspace Context

Before starting any task, read `config/workspace.yaml` to load workspace settings:

- `workspace.owner` — who you are working for
- `workspace.company` — the company name
- `workspace.language` — **always respond and write documents in this language** (never hardcode)
- `workspace.timezone` — use for all date/time references
- `workspace.name` — the workspace name

Defer to `workspace.yaml` as the source of truth. Never hardcode language, owner, or company.

## Shared Knowledge Base

Beyond your own agent memory in `.claude/agent-memory/custom-{name}/`, you have **read and write access** to a shared knowledge base at `memory/`. Start by reading `memory/index.md` — it catalogs everything available.

- `memory/index.md` — catalog of the shared knowledge base (read first)
- `memory/people/` — profiles of team members, partners, vendors
- `memory/projects/` — project context and history
- `memory/context/company.md` — organizational structure, tools, ceremonies
- `memory/glossary.md` — internal terms, acronyms, nicknames
- `memory/trends/` — weekly metric snapshots

**Read from `memory/` whenever:** the user mentions a person by name or nickname, uses an internal acronym, refers to a project by shorthand, or needs company context.

**Write to `memory/` when:** you learn something durable and shared — either because the user asks or because the context clearly requires it. Ephemeral or agent-specific notes stay in your own `.claude/agent-memory/custom-{name}/` folder.

## Working Folder

Your workspace folder: `workspace/{sector}/` — {what goes here: outputs, reports, artifacts}. Create the directory if it does not exist. All outputs you produce go here.

**Shared read access:** You can read `workspace/projects/` for context on active git projects, but never write there — that folder is reserved for git repositories owned by the user.

> **Skip this section** if the agent is a pure orchestrator (like Clawdia) or knowledge-only (like Oracle) and does not need its own writable folder. In that case, explain in 1-2 sentences where the agent's outputs live (if any) and what it reads.

## Your Domain

{Detailed description of what this agent handles. Be specific about:}
- What tasks fall under this domain
- What data sources it accesses
- What outputs it produces

## Personality

- {personality trait 1}
- {personality trait 2}
- {personality trait 3}

## How You Work

1. Always read your memory folder first: `.claude/agent-memory/custom-{name}/`
2. {workflow step}
3. {workflow step}
4. Save learnings to your memory folder

## Skills You Can Use

{List relevant existing skills or note that custom skills can be created}

## Anti-patterns

- Do NOT {thing to avoid}
- Do NOT {thing to avoid}
- Do NOT mix with other agent domains
- Do NOT hardcode language, owner, or company — always defer to `config/workspace.yaml`
```

## Naming the Working Folder

Use the **sector/domain name**, not the agent's name:

| Good (sector) | Bad (agent name) |
|---|---|
| `workspace/devops/` | `workspace/devon/` |
| `workspace/qa/` | `workspace/quinn/` |
| `workspace/security/` | `workspace/sentinel/` |

Why: when the user navigates the filesystem, they think in terms of work areas, not agent identities. If you later rename the agent, the folder stays stable.

## Step 3: Generate the Slash Command

Create `.claude/commands/custom-{name}.md`:

```markdown
---
description: "{short description} — custom agent"
allowed-tools: ["Agent"]
---

Launch the custom-{name} agent.

Use the Agent tool with `subagent_type: "custom-{name}"` to handle this request. The agent has its own memory in `.claude/agent-memory/custom-{name}/` and its system prompt in `.claude/agents/custom-{name}.md`.
```

## Step 4: Register in Dashboard (core agents only)

If the agent does NOT have the `custom-` prefix (i.e., it's a core agent that will be committed to the repo), add it to `AGENT_META` in `dashboard/frontend/src/pages/Agents.tsx`:

1. Add the icon import from `lucide-react` at the top of the file
2. Add an entry to the `AGENT_META` object:

```typescript
'{agent-name}': {
  icon: {IconName},
  color: '{hex color from frontmatter}',
  colorMuted: '{color}1F',
  glowColor: '{color}26',
  command: '/{command-name}',
  label: '{domain label}',
},
```

Without this step, the agent card in the dashboard will show a generic icon and no `/command` badge.

**Skip this step for custom agents** — they use `DEFAULT_META` with dynamic colors from frontmatter automatically.

## Step 5: Create Memory Folder

```bash
mkdir -p .claude/agent-memory/custom-{name}
```

The memory folder is already gitignored (`.claude/agent-memory/` is in `.gitignore`).

## Step 6: Verify

Run a quick check:
```bash
ls -la .claude/agents/custom-{name}.md
ls -la .claude/commands/custom-{name}.md
ls -d .claude/agent-memory/custom-{name}/
```

Tell the user:
- Agent created: `custom-{name}`
- Invoke with: `/custom-{name}` in Claude Code
- Visible in dashboard: Agents page (with "custom" badge)
- Memory: `.claude/agent-memory/custom-{name}/`
- To delete: remove the 3 paths above

## Agent Naming Convention

| Pattern | Example | Domain |
|---------|---------|--------|
| `custom-devops` | DevOps agent | Infrastructure monitoring |
| `custom-support` | Support agent | Customer tickets |
| `custom-legal` | Legal agent | Contract review |
| `custom-data` | Data agent | Analytics, ETL |
| `custom-qa` | QA agent | Testing, quality |

Rules:
- Always use `custom-` prefix (required for gitignore and dashboard badge)
- Use lowercase, hyphen-separated names
- Keep names short (1-2 words after prefix)
- Avoid names that conflict with core agents

## Core Agents (Do Not Duplicate)

These domains are already covered by core agents:

| Agent | Domain |
|-------|--------|
| `clawdia-assistant` | Operations, calendar, email, tasks |
| `flux-finance` | Finance, Stripe, ERP |
| `atlas-project` | Projects, GitHub, Linear |
| `pulse-community` | Community, Discord, WhatsApp |
| `pixel-social-media` | Social media, content |
| `sage-strategy` | Strategy, OKRs |
| `nex-sales` | Sales, pipeline |
| `mentor-courses` | Courses, education |
| `kai-personal-assistant` | Personal, health, habits |

If the user's request overlaps with a core agent, suggest using that agent instead or creating the custom agent for the specific subset that's different.

## Important Notes

- Custom agents (`custom-*`) are gitignored — they won't be pushed to the repo
- Custom commands (`custom-*`) are also gitignored
- Agent memory is always gitignored (all of `.claude/agent-memory/`)
- The dashboard auto-discovers custom agents and shows them with a gray "custom" badge
- Custom agents can use any existing skill — just list them in the system prompt
- To create custom skills for the agent, use the skill naming convention: `.claude/skills/{prefix}-{action}/`