Przejdź do treści
Biblioteka skilli
AI i agenci · Budowanie i kod

agent-builder

/agent-builder

Tworzy nowych subagentów przez generowanie plików YAML i promptów w ~/.flocks/plugins/agents/, do których Rex może delegować zadania.

Repozytorium
flocks ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
19.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 19.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Tworzy nowych subagentów przez generowanie plików YAML i promptów w ~/.flocks/plugins/agents/, do których Rex może delegować zadania.

Oryginalny opis (EN)

Create new sub-agents (subagents) by generating YAML config and prompt files in ~/.flocks/plugins/agents/. The created agent can be delegated to by Rex via delegate_task. Use when the user asks to create, add, or generate a new agent.

Jak działa

  1. Workflow
  2. Constraints
Sekcje z nagłówków SKILL.md, w oryginale · 196 linii, 985 słów
Podgląd SKILL.md
---
name: agent-builder
group: 系统辅助
category: system
description: Create new sub-agents (subagents) by generating YAML config and prompt files in ~/.flocks/plugins/agents/. The created agent can be delegated to by Rex via delegate_task. Use when the user asks to create, add, or generate a new agent.
---

# Agent Builder

Create a new sub-agent from user requirements. Produces a YAML config file + prompt file under `~/.flocks/plugins/agents/<name>/`, loadable by the system without restart.

**Required directory layout:**
```
~/.flocks/plugins/agents/
└── {name}/          ← subdirectory named after the agent (kebab-case)
    ├── agent.yaml   ← YAML config
    └── prompt.md    ← system prompt
```

> ⚠️ Do NOT create flat files like `agents/{name}.yaml` — the subdirectory format is mandatory.

---

## Workflow

### 1. Clarify Requirements

Use the `Question` tool to confirm (skip if already clear):

- **Agent name**: `kebab-case` format (e.g. `threat-analyst`, `code-reviewer`)
- **Role description**: one-sentence summary of the agent's specialty
- **Capability boundary**: what the agent can and cannot do
- **Execution mode**: read-only analysis (`read_only`) / general execution (`react`) / plan-then-execute (`plan_and_execute`) / codebase exploration (`explore`)

### 2. Generate Prompt File

Create `~/.flocks/plugins/agents/{name}/prompt.md` with the following structure:

```markdown
You are a specialized {role} agent.

## Mission
{Core responsibilities, 1-2 paragraphs}

## Capabilities
- **Capability 1**: specific description
- **Capability 2**: specific description

## Output Format
{Structured output requirements: tables, checklists, etc.}

## Constraints
- {Constraint 1}
- {Constraint 2}
```

**Prompt writing principles**:
- Open with a clear role identity
- List concrete capabilities, not vague descriptions
- Define a structured output format so callers can use results directly
- Constraints must be consistent with the declared `tools` allowlist (e.g. a read-only agent should not claim it can edit files)

### 3. Generate YAML Config File

Create `~/.flocks/plugins/agents/{name}/agent.yaml`. Prefer an explicit `tools` allowlist; use `permission` only for advanced wildcard matching or deny/allow patterns that cannot be expressed as a simple list.

```yaml
# Required
name: {name}                    # kebab-case, globally unique
description: >                  # One-sentence description; Rex uses this to decide when to delegate
  {Agent's role and specialty}

# Behavior
mode: subagent                  # Always "subagent" for sub-agents
strategy: read_only             # react | plan_and_execute | read_only | explore
delegatable: true               # Whether delegate_task can invoke this agent
hidden: false                   # Whether to hide from the frontend

# Prompt source (pick one)
prompt_file: prompt.md          # External prompt.md in the same directory (recommended)
# prompt: "inline prompt..."    # Inline (for short prompts)
# prompt_builder: "module:func" # Dynamic Python builder (advanced)

# Optional
color: "#E74C3C"                # Frontend display color, 6-digit hex
temperature: 0.3                # 0.0 - 1.0
# top_p: null
# steps: 50                    # Max execution steps

# Model override (optional; omit to use the global default)
# model:
#   provider_id: custom-openai-compatible
#   model_id: "claude-sonnet-4-5-20250929"

# Preferred tool allowlist
tools:
  - read                        # Open as needed
  - grep
  - glob
  # - bash                      # When shell execution is needed
  # - edit                      # Covers write/edit/apply_patch-style file mutations
  # - websearch                 # When web search is needed
  # - webfetch                  # When web fetching is needed
  # - delegate_task             # When re-delegation is needed (use with caution)

# Advanced / legacy alternative when wildcard rules are really needed
# permission:
#   "*": deny
#   read: allow
#   grep: allow
#   glob: allow

# Delegation metadata (tells Rex when to delegate to this agent)
prompt_metadata:
  category: {domain}            # Domain category, e.g. security / code-quality / devops
  cost: medium                  # CHEAP / medium / EXPENSIVE
  triggers:
    - domain: {trigger_domain}
      trigger: "{trigger condition description}"
  use_when:
    - "{applicable scenario 1}"
    - "{applicable scenario 2}"
  avoid_when:
    - "{inapplicable scenario}"
```

### 4. Strategy Selection Guide

| Strategy | Use Case | Tool Scope | Example Agents |
|----------|----------|------------|----------------|
| `read_only` | Analysis/consultation only, no file mutations | Read-only tools | oracle, librarian |
| `react` | General execution, observe-think-act loop | All tools | general |
| `plan_and_execute` | Complex tasks requiring planning before execution | All tools | rex, hephaestus |
| `explore` | Codebase exploration and search | Search/read tools | explore |

### 5. Tool Templates

**Read-only analysis** (e.g. code review, security audit):
```yaml
tools:
  - read
  - grep
  - glob
```

**Read-only + network** (e.g. documentation lookup, threat intelligence):
```yaml
tools:
  - read
  - grep
  - glob
  - bash
  - websearch
  - webfetch
```

**Full execution** (e.g. code generation, refactoring):
```yaml
tools:
  - read
  - grep
  - glob
  - edit
  - bash
  - websearch
  - webfetch
```

**Tool naming rules**:
- Prefer the exact tool names currently registered in the system; do not guess or invent names.
- For ThreatBook MCP tools in this project, use the concrete prefixed names such as `threatbook_mcp_ip_query` and `threatbook_mcp_hrti_query`.
- More generally, when an MCP server in the project has a stable prefix convention, keep that prefix in agent YAML instead of replacing it with a generic alias.
- Do not mix the old `permission` style and the new `tools` style in the same agent unless there is a very specific reason.

### 6. Validation

After generating files, verify:

1. **YAML syntax**: run `python3 -c "import yaml; from pathlib import Path; yaml.safe_load(Path('~/.flocks/plugins/agents/{name}/agent.yaml').expanduser().read_text(encoding='utf-8'))"`
2. **Prompt file exists**: confirm `~/.flocks/plugins/agents/{name}/prompt.md` has been created
3. **Directory structure**: ensure files are inside `~/.flocks/plugins/agents/{name}/`, NOT as flat files like `agents/{name}.yaml`
4. **Name uniqueness**: ensure no collision with built-in agents (reserved names: rex, hephaestus, oracle, librarian, explore, prometheus, multimodal-looker, rex-junior, build, plan, compaction, title, summary)
5. **Tool names**: verify every listed tool exists in the current registry; if the repo exposes a `/tools` or tool listing command, check against that instead of relying on memory

### 7. Output

After creation, inform the user:
- File paths created (e.g. `~/.flocks/plugins/agents/{name}/agent.yaml` and `prompt.md`)
- Agent name and role
- Can be invoked via `delegate_task(subagent_type="{name}", ...)`

---

## Constraints

- Agent names must be `kebab-case` (lowercase letters + digits + hyphens)
- `mode` is always `subagent` (this skill only creates sub-agents)
- **Files MUST be written to `~/.flocks/plugins/agents/<name>/` subdirectory** — flat files like `agents/<name>.yaml` are legacy and should NOT be created
- The subdirectory name must match the agent `name` field exactly
- Do not create agents with names that collide with built-in agents
- Prefer `tools:` over `permission:` for new agents so the config stays aligned with the current UI and loader behavior

Wersje

RepozytoriumWynikLicencja
Ta strona · agentflocks/flocks100Apache-2.0
railtownai/railtracks100MIT
shareai-lab/learn-claude-code100MIT
baddelta/agent-builder100MIT
mathews-tom/armory100MIT
DineshKuppan/claude-skill-library100MIT
naveedharri/benai-skills100MIT
testdouble/han100MIT
pr-pm/prpm91MIT

Migawka bazy z 13.11.2026 · wersja paczki a2b393622d8f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90pi-rex-agents
    Wyjaśnia, jak delegować pracę podagentom w Rex, zarządzać worktree i odbierać wyniki, a agenci potomni nie zlecają dalszej pracy.
  • 100device-integration-guide
    Prowadzi przez tworzenie, dodawanie i podłączanie nowych urządzeń bezpieczeństwa do platformy Flocks.
  • 100rex-subagents
    Uruchamia podagenty pi w osobnych panelach Rex, równolegle w tle, i automatycznie odbiera od nich wyniki i pytania.
  • 95workflow-builder
    Generuje workflow dla flocks na podstawie opisu w języku naturalnym, np. dla alarmów, reagowania na incydenty lub SOP.
  • 100rex-teams
    Pracuje z innymi agentami w Rex: uruchamia je jako podagentów w tle, wysyła im wiadomości w trakcie zadania i odbiera ich raporty.
  • 100rex-agent
    Zarządza flotą agentów AI w terminalu Rex: uruchamia root i pracowników w jednej karcie, wysyła polecenia i czyta ich wyniki.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.