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

agent-creator

/agent-creator

Tworzy komponowalne systemy agentów AI w projektach NestJS w architekturze „narzędzia aż do dołu”: orkiestrator, planer, wykonawca i ewaluator, planowanie DAG i stan runów w bazie.

Licencja
MIT
Ostatnia zmiana repozytorium
13.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
5
Skrypty
0
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Tworzy komponowalne systemy agentów AI w projektach NestJS w architekturze „narzędzia aż do dołu”: orkiestrator, planer, wykonawca i ewaluator, planowanie DAG i stan runów w bazie.

Wyzwalacze z opisu

tools all the way downcreate agentbuild agentagent systemagenticorchestratorplanner/executor pattern
Oryginalny opis (EN)

Create composable AI agent systems in NestJS projects following the "tools all the way down" architecture. Use this skill when users want to: (1) Create new AI agents with orchestrator/planner/executor/evaluator components, (2) Build agentic systems that can call other agents as tools, (3) Implement DAG-based planning with parallel execution, (4) Add database-backed state persistence for agent runs, (5) Create custom evaluators for quality assurance. Triggers on "create agent", "build agent", "agent system", "agentic", "orchestrator", "planner/executor pattern", or NestJS AI agent requests.

Jak działa

  1. Contents
  2. Core Concept
  3. Workflow
  4. Key Architecture Rules
  5. Quick Reference
  6. Composition Example
Sekcje z nagłówków SKILL.md, w oryginale · 171 linii, 569 słów
Podgląd SKILL.md
---
name: agent-creator
description: |
  Create composable AI agent systems in NestJS projects following the "tools all the way down" architecture. Use this skill when users want to: (1) Create new AI agents with orchestrator/planner/executor/evaluator components, (2) Build agentic systems that can call other agents as tools, (3) Implement DAG-based planning with parallel execution, (4) Add database-backed state persistence for agent runs, (5) Create custom evaluators for quality assurance. Triggers on "create agent", "build agent", "agent system", "agentic", "orchestrator", "planner/executor pattern", or NestJS AI agent requests.
---

# Agent Creator

<!-- contents: generated by tests/skill_structure.py --write; edit headings, not this block -->
## Contents

- [Core Concept](#core-concept)
- [Workflow](#workflow)
  - [1. Gather Requirements](#1-gather-requirements)
  - [2. Generate Agent Structure](#2-generate-agent-structure)
  - [3. Implement Components](#3-implement-components)
  - [4. Wire Up Module](#4-wire-up-module)
- [Key Architecture Rules](#key-architecture-rules)
- [Quick Reference](#quick-reference)
  - [Tool Interface](#tool-interface)
  - [Plan Structure](#plan-structure)
  - [Default Config](#default-config)
- [Composition Example](#composition-example)

Reference files (open one when a step points to it):
- `references/architecture.md`: Agent Architecture Reference
- `references/evaluators.md`: Evaluators Reference
- `references/nestjs-patterns.md`: NestJS Patterns Reference
- `references/prompts.md`: System Prompts Reference
<!-- /contents -->

Create composable AI agent systems in NestJS with uniform tool interfaces, DAG-based planning, and database-backed state.

## Core Concept

Every agent system exposes the same `Tool` interface as a simple tool. Callers don't know if they're calling a web search API or a complex research system. This enables arbitrary composition and nesting.

## Workflow

### 1. Gather Requirements

Ask the user:

1. **Purpose**: What should this agent accomplish?
2. **Inputs/Outputs**: What data goes in and comes out?
3. **Tools**: What capabilities does it need? (existing tools or other agents)
4. **Success Criteria**: How do we know the output is good?
5. **Evaluator Types**: What quality dimensions matter? (see [evaluators.md](references/evaluators.md))

### 2. Generate Agent Structure

Create this NestJS module structure:

```
src/agents/{agent-name}/
├── {agent-name}.module.ts           # NestJS module
├── {agent-name}.tool.ts             # Tool interface (public API)
├── services/
│   ├── orchestrator.service.ts      # Workflow coordination
│   ├── planner.service.ts           # Plan generation
│   ├── executor.service.ts          # Tool execution
│   └── state.service.ts             # State management
├── evaluators/
│   ├── evaluator.registry.ts        # Registry service
│   └── {type}.evaluator.ts          # Per evaluator type
├── tools/
│   └── tool.registry.ts             # Available tools
├── entities/                         # TypeORM entities
├── dto/                              # Input/output DTOs
├── prompts/                          # LLM prompts
├── config/
│   └── {agent-name}.config.ts
└── interfaces/
```

### 3. Implement Components

For each component, follow the patterns in:
- [architecture.md](references/architecture.md) - Core interfaces, component roles, loops
- [nestjs-patterns.md](references/nestjs-patterns.md) - NestJS service templates
- [prompts.md](references/prompts.md) - System prompts for planner/executor/evaluators
- [evaluators.md](references/evaluators.md) - Built-in evaluator types

### 4. Wire Up Module

```typescript
@Module({
  imports: [TypeOrmModule.forFeature([...entities])],
  providers: [
    OrchestratorService,
    PlannerService,
    ExecutorService,
    StateService,
    EvaluatorRegistry,
    ...evaluators,
    ToolRegistry,
    AgentTool,
  ],
  exports: [AgentTool], // Only export the Tool interface
})
export class AgentNameModule {}
```

## Key Architecture Rules

1. **Uniform Interface**: Agent's public API is always `Tool.execute(input, context)`
2. **Planning Loop**: plan → evaluate plan → revise → repeat (max iterations)
3. **Execution Loop**: execute step → evaluate → retry with feedback → repeat
4. **DAG Plans**: Steps declare dependencies; independent steps run in parallel
5. **State Persistence**: All context, messages, plans, executions stored in PostgreSQL
6. **Composition**: Agents can use other agents as tools transparently

## Quick Reference

### Tool Interface

```typescript
interface Tool {
  id: string;
  name: string;
  description: string;
  inputSchema: JSONSchema;
  outputSchema: JSONSchema;
  execute(input: any, context?: ExecutionContext): Promise<ToolResult>;
}
```

### Plan Structure

```typescript
interface Plan {
  id: string;
  goal: string;
  success_criteria: string[];
  steps: PlanStep[];
}

interface PlanStep {
  id: string;
  description: string;
  tool_id: string;
  input: any;
  success_criteria: string[];
  evaluator_type: string;
  depends_on: string[];  // DAG dependencies
}
```

### Default Config

```typescript
export const agentConfig = {
  maxDepth: 3,
  maxPlanIterations: 3,
  maxStepRetries: 3,
  timeoutMs: 300000,
  llm: { model: 'claude-sonnet-4-20250514', maxTokens: 4096 },
};
```

## Composition Example

After creating `research-agent` and `document-generator`:

```typescript
// document-generator/tools/tool.registry.ts
@Injectable()
export class ToolRegistry {
  constructor(private readonly researchTool: ResearchTool) {
    this.register(this.researchTool);
  }
}
```

The document generator's planner can now create steps using `research-system-v1` as a tool_id.
Pliki w paczce (5)
  • SKILL.md 6 KB
  • references/architecture.md 10 KB
  • references/evaluators.md 14 KB
  • references/nestjs-patterns.md 24 KB
  • references/prompts.md 10 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · mhylle/claude-skills-collection100MIT
jeremylongshore/tons-of-skills-marketplace100MIT
Navinspire-ia/navin100AGPL-3.0
hotovo/aider-desk100Apache-2.0
OpenHands/extensions100MIT
openjiuwen-ai/jiuwenswarm100Apache-2.0
agdev/claude-code100MIT
krzysztofsurdy/code-virtuoso100MIT
fusengine/agents100MIT

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

Pobrania w ostatnich 30 dniach: 1 · ranking

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

Podobne skille

  • 100tool-creator
    Tworzy nowe narzędzia dla systemu agentów Strands SDK: agentów opakowanych jako narzędzia lub proste funkcje.
  • 95ai-agentic-workflows
    Projektuje przepływ sterowania wokół LLM: wybiera wzorzec, ogranicza pętle i wskazuje miejsca, w których człowiek sprawdza wynik.
  • 100dag-runtime
    Wykonuje przepływy DAG z równoległym przetwarzaniem fal, uruchamianiem agentów, izolacją kontekstu, egzekwowaniem uprawnień i pełnym śladem wykonania.
  • 100create-agent
    Tworzy i aktualizuje instancje agentów AI w Harness, czyli samodzielne szablony przepływów agentowych w pipeline'ach.
  • 100agent-builder
    Pomaga projektować i budować agentów AI dla dowolnej dziedziny: architektura agentów, wzorce agentowe, subagenci, planowanie i mechanizm skilli.
  • 95ai-agent-architectures
    Projektuje architekturę pojedynczego agenta AI: pętlę działania, narzędzia, pamięć, planowanie i ewaluację.

Uwagi i zgłoszenia

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