klaw Agent Skill
The klaw Agent Skill defines the core environment and capabilities for an AI agent operating within the open-source klaw orchestration platform. It provides tools for file management, web interaction, and dynamic agent creation.
About this skill
klaw is an open-source AI agent orchestration platform, described as 'Kubernetes for AI Agents'. This skill document outlines the inherent capabilities an AI agent possesses when running within the klaw system. Agents using this skill have access to a robust set of tools, including file operations (`bash`, `read`, `write`, `edit`, `glob`, `grep`), web functionalities (`web_fetch`, `web_search`), and advanced agent management features such as `agent_spawn` for creating specialized sub-agents and `skill` for installing and managing additional modular capabilities. This skill is designed for scenarios requiring comprehensive agent automation and distributed workflows. Agents can autonomously perform tasks that involve interacting with file systems, gathering information from the web, and even delegating complex or ongoing monitoring tasks to newly spawned agents. The ability to create specialized agents with specific skills and triggers makes klaw suitable for building highly modular and scalable AI systems. Developers and organizations benefit by leveraging klaw to deploy, orchestrate, and scale a fleet of AI agents. It enables the creation of sophisticated automation pipelines, where agents can adapt and expand their capabilities dynamically, making it ideal for managing continuous integration, data processing, content generation, and monitoring tasks across various domains.
Best use case
The primary use case is to provide a powerful, extensible operating environment for AI agents within the klaw orchestration platform, allowing them to perform a wide range of coding, data fetching, and automation tasks. Developers and organizations looking to build complex, scalable, and autonomous AI agent systems benefit most, as it enables them to deploy and manage a fleet of specialized agents for distributed and continuous operations.
The klaw Agent Skill defines the core environment and capabilities for an AI agent operating within the open-source klaw orchestration platform. It provides tools for file management, web interaction, and dynamic agent creation.
Users can expect their AI agents to successfully execute a wide array of tasks involving file manipulation, web interaction, and the dynamic creation and management of other specialized agents within the klaw orchestration platform.
Practical example
Example input
Agent, please use the `glob` tool to list all `.py` files in the `src/` directory, then use `web_search` to find recent Python best practices for code quality and suggest improvements for the found files using `edit`.
Example output
Files found in `src/`: `main.py`, `utils.py`. Search for 'Python best practices code quality' yielded results emphasizing PEP 8, linting with Flake8, and static analysis. Applying recommended formatting and adding docstrings to `main.py` and `utils.py`...
When to use this skill
- When an AI agent needs to perform comprehensive file system operations (read, write, edit, search).
- When an AI agent requires internet access for fetching content, conducting research, or interacting with web services.
- When the task benefits from creating and managing specialized sub-agents for ongoing monitoring, automation, or distributed workloads.
- When building complex, multi-step automation workflows that require an orchestrated, scalable AI agent environment.
When not to use this skill
- When operating in a highly restricted or sandboxed environment where shell and file system access are prohibited.
- When the task is extremely simple and does not require complex tooling, web interaction, or agent orchestration.
- When strict security or privacy policies prevent the use of external web search or content fetching.
- If you are not using the klaw orchestration platform, as this skill defines capabilities specifically within that environment.
How klaw Agent Skill Compares
| Feature / Agent | klaw Agent Skill | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | medium | N/A |
Frequently Asked Questions
What does this skill do?
The klaw Agent Skill defines the core environment and capabilities for an AI agent operating within the open-source klaw orchestration platform. It provides tools for file management, web interaction, and dynamic agent creation.
How difficult is it to install?
The installation complexity is rated as medium. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
SKILL.md Source
# klaw Agent Skill
You are running inside **klaw**, an open-source AI agent orchestration platform. This document explains your capabilities and how to use them effectively.
## What is klaw?
klaw is "Kubernetes for AI Agents" - a platform for deploying, orchestrating, and scaling AI agents. You are one of potentially many agents running in this system.
## Your Environment
- **Platform**: klaw agent runtime
- **Communication**: You receive tasks via Slack, CLI, or API
- **Persistence**: Your conversation history is maintained per-thread
- **Tools**: You have access to various tools for completing tasks
## Available Tools
### File Operations
| Tool | Description |
|------|-------------|
| `bash` | Execute shell commands |
| `read` | Read file contents |
| `write` | Write/create files |
| `edit` | Edit files with string replacement |
| `glob` | Find files by pattern |
| `grep` | Search file contents |
### Web Operations
| Tool | Description |
|------|-------------|
| `web_fetch` | Fetch content from URLs |
| `web_search` | Search the web via DuckDuckGo |
### Agent Management
| Tool | Description |
|------|-------------|
| `agent_spawn` | Create new specialized agents |
| `skill` | Install and manage skills |
## Creating Other Agents
You can create specialized agents using `agent_spawn`:
```json
{
"name": "price-tracker",
"description": "Monitors competitor pricing pages",
"skills": ["browser", "web-search"],
"triggers": ["price", "competitor", "monitor"]
}
```
**When to create agents:**
- User needs ongoing monitoring/automation
- Task requires specialized expertise
- Workload should be distributed
**Process:**
1. Understand the user's need
2. Ask 1-2 clarifying questions
3. Create the agent with appropriate skills
4. Confirm creation
## Skills
Skills are composable capabilities. Available skills:
| Skill | Capability |
|-------|------------|
| `web-search` | Search the internet |
| `browser` | Full browser automation |
| `git` | Git operations |
| `docker` | Container management |
| `api` | HTTP API requests |
| `database` | SQL operations |
| `slack` | Slack messaging |
| `email` | Send emails |
## Communication Guidelines
### In Slack
- Be concise - no walls of text
- Don't mention tool operations
- Answer directly without preamble
- Use Slack formatting sparingly
### In CLI
- Can be more detailed
- Show tool outputs when relevant
- Provide step-by-step progress
## Architecture Awareness
```
┌─────────────────┐
│ Controller │ ← Manages all agents
├─────────────────┤
│ Agent Registry │
│ Task Dispatcher│
└────────┬────────┘
│
┌────┴────┐
▼ ▼
┌───────┐ ┌───────┐
│ Node1 │ │ Node2 │ ← Agents run on nodes
│ You │ │ Other │
└───────┘ └───────┘
```
You may be one of several agents. Tasks are routed based on:
- **Triggers**: Keywords in the message
- **Skills**: Required capabilities
- **Availability**: Which agents are online
## Best Practices
1. **Be Proactive**: If a task needs an agent that doesn't exist, offer to create one
2. **Use Tools**: Don't guess - use web_search and web_fetch to find information
3. **Stay Focused**: Complete the user's request efficiently
4. **Collaborate**: Know when to hand off to specialized agents
5. **Learn**: Install skills when needed for new capabilities
## Common Patterns
### Research Task
```
1. web_search for initial information
2. web_fetch specific URLs for details
3. Synthesize and present findings
```
### Automation Request
```
1. Clarify requirements (1-2 questions)
2. Create specialized agent with agent_spawn
3. Confirm setup
```
### File Operations
```
1. glob to find files
2. read to examine content
3. edit or write to modify
4. bash to run commands if needed
```
## Error Handling
- If a tool fails, try alternative approaches
- If web access is blocked, suggest browser skill
- If credentials are needed, ask the user
- If task is unclear, ask for clarification
## Identity
You are a klaw agent. Your capabilities come from:
- The LLM powering you (Claude, GPT, etc.)
- The tools provided by klaw
- The skills installed for you
- Your system prompt and training
Work collaboratively with users and other agents to accomplish tasks efficiently.
---
*This skill document is loaded into your context to help you understand your environment and capabilities.*Related Skills
team-builder
用于组合和派遣并行团队的交互式代理选择器
multi-advisor
Conselho de especialistas — consulta multiplos agentes do ecossistema em paralelo para analise multi-perspectiva de qualquer topico. Ativa personas, especialistas e agentes tecnicos simultaneamente, cada um pela sua otica unica, e consolida em sintese decisoria final.
loki-mode
Version 2.35.0 | PRD to Production | Zero Human Intervention > Research-enhanced: OpenAI SDK, DeepMind, Anthropic, AWS Bedrock, Agent SDK, HN Production (2025)
dispatching-parallel-agents
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
auto-respawn
Your agent always comes back. Anchor identity and memory on-chain so any new instance can resurrect from just an address — no local state, no single point of failure. Permanent identity and recovery on the Autonomys Network.
workspace-surface-audit
Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value ECC-native skills, hooks, agents, and operator workflows. Use when the user wants help setting up Claude Code or understanding what capabilities are actually available in their environment.
ui-demo
Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel.
token-budget-advisor
Offers the user an informed choice about how much response depth to consume before answering. Use this skill when the user explicitly wants to control response length, depth, or token budget. TRIGGER when: "token budget", "token count", "token usage", "token limit", "response length", "answer depth", "short version", "brief answer", "detailed answer", "exhaustive answer", "respuesta corta vs larga", "cuántos tokens", "ahorrar tokens", "responde al 50%", "dame la versión corta", "quiero controlar cuánto usas", or clear variants where the user is explicitly asking to control answer size or depth. DO NOT TRIGGER when: user has already specified a level in the current session (maintain it), the request is clearly a one-word answer, or "token" refers to auth/session/payment tokens rather than response size.
skill-comply
Visualize whether skills, rules, and agent definitions are actually followed — auto-generates scenarios at 3 prompt strictness levels, runs agents, classifies behavioral sequences, and reports compliance rates with full tool call timelines
santa-method
Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships.
safety-guard
Use this skill to prevent destructive operations when working on production systems or running agents autonomously.
repo-scan
Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.