Skip to content
Skills Library
AI & agents · Building & coding

agent-development

/agent-development

Design and build AI agents with persistent memory, tool use, and multi-turn conversation. Covers architecture selection, memory design, model selection, tool configuration, and implementation patterns across agent frameworks. Use when creating, debugging, or improving AI agents.

Licence
MIT
Last repository change
20.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
9
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 20.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Design and build AI agents with persistent memory, tool use, and multi-turn conversation. Covers architecture selection, memory design, model selection, tool configuration, and implementation patterns across agent frameworks. Use when creating, debugging, or improving AI agents.

Original author description

Design and build AI agents with persistent memory, tool use, and multi-turn conversation. Covers architecture selection, memory design, model selection, tool configuration, and implementation patterns across agent frameworks. Use when creating, debugging, or improving AI agents.

How it works

  1. When to Use
  2. Architecture Selection
  3. Memory Architecture
  4. Memory Block Design
  5. Model Selection
  6. Tool Configuration
  7. Advanced Topics
  8. Implementation Examples
  9. Validation Checklist
  10. Common Antipatterns
Original SKILL.md headings · 198 lines, 989 words
SKILL.md preview
---
name: agent-development
description: Design and build AI agents with persistent memory, tool use, and multi-turn conversation. Covers architecture selection, memory design, model selection, tool configuration, and implementation patterns across agent frameworks. Use when creating, debugging, or improving AI agents.
license: MIT
metadata:
  author: greedychipmunk
  version: "1.0"
---

# Agent Development

Design and build effective AI agents with appropriate architectures, memory configurations, model selection, and tool setups. Works across any agent framework or custom implementation.

## When to Use

- Starting a new agent project
- Choosing between agent architectures (single-agent, multi-agent, stateless, stateful)
- Designing memory structure and context management
- Selecting appropriate models for your use case
- Planning tool configurations
- Optimizing memory management and performance
- Implementing shared memory between agents
- Debugging memory-related issues

## Architecture Selection

| Architecture | When to use |
| --- | --- |
| **Single agent, stateful** | Most common case. Agent maintains context across turns. Best for personal assistants, coding agents, support bots. |
| **Single agent, stateless** | Simple request/response patterns. No conversation memory needed. Good for one-shot tools. |
| **Multi-agent, shared memory** | Complex workflows where different agents specialize. Coordinate via shared memory blocks or message passing. |
| **Multi-agent, orchestrated** | Pipeline or fan-out patterns. A router agent dispatches to specialist agents. |

Read `resources/architectures.md` for detailed comparison and tradeoffs.

## Memory Architecture

Three memory types cover most agent needs:

**Core Memory (in-context):**
- Always accessible in the agent's context window
- Use for: current state, active context, frequently referenced information
- Limit: Keep total core memory under 80% of context window

**Archival Memory (out-of-context):**
- Semantic search over vector database or document store
- Use for: historical records, large knowledge bases, past interactions
- Access: Agent must explicitly search — not automatically populated from context overflow

**Conversation History:**
- Past messages from current conversation
- Use for: referencing earlier discussion, tracking conversation flow
- Older messages may be evicted; store durable facts in core/archival memory

Read `resources/memory-architecture.md` for detailed guidance.

## Memory Block Design

**Core principle:** One block per distinct functional unit.

**Essential blocks:**
- `persona`: Agent identity, behavioral guidelines, capabilities
- `human`: User information, preferences, context

**Add domain-specific blocks based on use case:**
- Customer support: `company_policies`, `product_knowledge`, `customer`
- Coding assistant: `project_context`, `coding_standards`, `current_task`
- Personal assistant: `schedule`, `preferences`, `contacts`

**Guidelines:**
- Keep blocks focused and purpose-specific
- Use clear, instructional descriptions
- Monitor size limits (typically 2000-5000 characters per block)
- Design for append operations when sharing memory between agents

Read `resources/memory-patterns.md` for domain examples and `resources/description-patterns.md` for writing effective descriptions.

## Model Selection

| Use case | Recommended tier |
| --- | --- |
| Complex reasoning, tool calling, multi-step plans | Frontier models (GPT-4o, Claude Sonnet 4, Gemini 2.5 Pro) |
| Cost-efficient general tasks | Mid-tier (GPT-4o-mini, Claude Haiku 3.5, Gemini 2.0 Flash) |
| Fast, lightweight operations | Small/fast models (Haiku, Flash) |

**Avoid for production agents:**
- Models without reliable function/tool calling support
- Small local models (<7B parameters) for tool-use-heavy agents

Read `resources/model-recommendations.md` for detailed guidance.

## Tool Configuration

**Start minimal:** Attach only tools the agent will actively use.

**Common starting points:**
- **Memory tools** (insert, replace, search): Core for most stateful agents
- **File system tools**: When the agent needs to read/write files
- **Custom tools**: For domain-specific operations (databases, APIs, etc.)

**Tool rules:** Enforce sequencing when needed (e.g., "always call search before answer").

Read `resources/tool-patterns.md` for common configurations.

## Advanced Topics

### Memory Size Management

When approaching character limits:
1. **Split by topic:** `customer_profile` → `customer_business`, `customer_preferences`
2. **Split by time:** `interaction_history` → `recent_interactions`, archive older to archival memory
3. **Archive historical data:** Move old information to archival memory
4. **Consolidate:** Summarize and rewrite block

Read `resources/size-management.md` for strategies.

### Concurrency Patterns

When multiple agents share memory or an agent processes concurrent requests:

**Safest operations:**
- Append-only writes (minimal race conditions)
- Database-backed storage with row-level locking

**Risk of race conditions:**
- Replace operations: target string may change before write
- Full rewrites: last-writer-wins, no merge

**Best practices:**
- Design for append operations when possible
- Reserve full rewrites for single-agent exclusive access

Read `resources/concurrency.md` for detailed patterns.

## Implementation Examples

### Python (SDK-based)

```python
agent = client.agents.create(
    name="my-agent",
    model="gpt-4o",
    memory_blocks=[
        {"label": "persona", "value": "You are a helpful assistant..."},
        {"label": "human", "value": "User preferences and context..."},
        {"label": "project", "value": "Current project details..."},
    ],
)
```

### TypeScript (SDK-based)

```typescript
const agent = await client.agents.create({
  name: "my-agent",
  model: "gpt-4o",
  memoryBlocks: [
    { label: "persona", value: "You are a helpful assistant..." },
    { label: "human", value: "User preferences and context..." },
    { label: "project", value: "Current project details..." },
  ],
});
```

### CLI-based

Most agent frameworks provide a CLI for interactive agent creation and configuration. Check your framework's documentation for creating new agents, setting names and descriptions, configuring memory blocks, and attaching tools.

## Validation Checklist

**Architecture:**
- [ ] Does the architecture match the model's capabilities?
- [ ] Is the model appropriate for expected workload and latency?

**Memory:**
- [ ] Is core memory total under 80% of context window?
- [ ] Is each block focused on one functional area?
- [ ] Are descriptions clear about when to read/write?
- [ ] Have you planned for size growth and overflow?
- [ ] If multi-agent, are concurrency patterns considered?

**Tools:**
- [ ] Are tools necessary and properly configured?
- [ ] Are memory blocks granular enough for effective updates?

## Common Antipatterns

**Too few memory blocks:** Everything in one block makes updates expensive and imprecise. Split into focused blocks.

**Too many memory blocks:** 10+ blocks when 3-4 would suffice. Start minimal, expand as needed.

**Poor descriptions:** `data: "Contains data"` tells the agent nothing. Provide actionable guidance about when to read/write.

**Ignoring size limits:** Blocks grow indefinitely until they hit limits. Monitor and manage proactively.

## Resources

- `resources/architectures.md` — Architecture comparison and selection
- `resources/memory-architecture.md` — Memory types and when to use them
- `resources/memory-patterns.md` — Domain-specific memory block examples
- `resources/description-patterns.md` — Writing effective block descriptions
- `resources/size-management.md` — Managing memory block size limits
- `resources/concurrency.md` — Multi-agent memory sharing patterns
- `resources/model-recommendations.md` — Model selection guidance
- `resources/tool-patterns.md` — Common tool configurations
Files in this package (9)
  • SKILL.md 8 KB
  • resources/architectures.md 3 KB
  • resources/concurrency.md 6 KB
  • resources/description-patterns.md 3 KB
  • resources/memory-architecture.md 3 KB
  • resources/memory-patterns.md 3 KB
  • resources/model-recommendations.md 2 KB
  • resources/size-management.md 4 KB
  • resources/tool-patterns.md 2 KB

Versions

RepositoryScoreLicence
This page · greedychipmunk/agent-skills100MIT
Navinspire-ia/navin100AGPL-3.0
anthropics/claude-plugins-official100Apache-2.0
davila7/claude-code-templates100MIT
tufflerp/Prabh-s-CSC100MIT
dwmkerr/claude-toolkit95MIT
proxify-dev/agentic-kit90MIT

Database snapshot: 13.11.2026 · package version abbbea390bcc (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95letta-development-guide
    Comprehensive guide for developing Letta agents, including architecture selection, memory design, model selection, and tool configuration. Use when building or troubleshooting Letta agents.
  • 90creating-claude-agents
    Use when creating or improving Claude Code agents. Expert guidance on agent file structure, frontmatter, persona definition, tool access, model selection, and validation against schema.
  • 95creating-claude-agents
    Use when creating or improving Claude Code agents. Expert guidance on agent file structure, frontmatter, persona definition, tool access, model selection, and validation against schema.
  • 91agent-builder
    Use when creating, improving, or troubleshooting Claude Code subagents. Expert guidance on agent design, system prompts, tool access, model selection, and best practices for building specialized AI assistants.
  • 100ai-agents-architect
    Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool ...
  • 100ai-agents-architect
    Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.