Browse skills

Build LlamaIndex applications that retrieve relevant material before generating answers, a method called RAG. Connect documents, websites, and databases to support document questions, conversational search, structured summaries, and checks of answer relevance and source consistency.

• Building question answering over internal documents
• Creating a chatbot that remembers the conversation
• Searching information across files, websites, and databases

Design collaborative AI teams with CrewAI by defining each agent’s role, goals, tasks, and expected results. Covers passing work between agents, manager-led coordination, memory settings, and execution planning for workflows such as research and writing.

• Build a team that researches and writes articles
• Coordinate specialists through a manager agent
• Define agent roles and expected task outputs

Train smaller language models using knowledge distillation, where a larger model supplies examples or prediction targets. This skill covers training losses, generated training data, parameter choices, and output comparisons to support model compression and specialized student models.

• Training a smaller model from a larger teacher
• Fine-tuning with teacher-generated responses
• Distilling domain knowledge into a specialized model

Build and operate AutoGPT agents that carry out multi-step workflows. Covers a visual editor for connecting processing blocks, scheduled and webhook triggers, deployment, execution monitoring, and benchmarks for evaluating agent performance.

• Build an AI workflow in a visual editor
• Run agents on a schedule or external event
• Add custom agent abilities with Forge

Build collaborating AI teams with CrewAI by defining roles, tasks, and shared context. Configure ordered execution or manager-led delegation, add memory and tools, and create workflows that branch based on events or results.

• Build a research-to-writing agent workflow
• Coordinate specialists through a manager agent
• Create workflows with conditional branches

Design autonomous coding agents using implementation patterns for tool calls, permission checks, browser interaction, and saved task state. Code examples and checklists help structure agent behavior and workflows that include human approval.

• Designing a coding agent's execution loop
• Defining tool interfaces for files and commands
• Adding permissions and human approval steps

Build AI applications with LangChain, including chatbots with conversation history and systems that search documents before answering. The skill provides examples for connecting models, calling tools, retrieving information, and tracing application runs.

• Building a chatbot that uses conversation history
• Creating a question-answering system for documents
• Developing an agent that calls external tools

Build AI agents that inspect screenshots, choose actions, and operate a mouse and keyboard. Covers the observation and action loop, desktop control examples, and isolated environments that restrict access to files, credentials, and networks.

• Build an AI agent that operates desktop screens
• Connect screenshot analysis to mouse and keyboard actions
• Design an isolated environment for automation

Run cognee in Docker, starting with a prebuilt image for local document ingestion and questions. It also covers Docker Compose profiles for adding the UI, MCP server, Postgres, and Neo4j, plus persistent data storage.

• Try cognee locally using a prebuilt Docker image
• Test document ingestion and questions through the API
• Start the UI, MCP server, and databases with Docker Compose

Connect cognee to model providers, databases, storage services, and development tools. Guides configuration of language models and embeddings, the numerical representations used for search, including the separate settings each requires.

• Switching model providers or using Ollama locally
• Connecting cognee to Postgres or Neo4j
• Storing cognee data in S3

Set up cognee and run a first Python example that stores information and retrieves it with a question. Covers virtual environments, API key configuration, optional packages, and basic troubleshooting.

• Installing cognee in a new Python environment
• Trying a minimal example that stores and retrieves information
• Separating stored information by project

Generate images from written descriptions through 9Router using a choice of image models. Check each model’s supported settings, request an image, and receive a URL, encoded image data, or image bytes for saving to a file.

• Creating a landscape image from a written description
• Checking supported image sizes and quality settings
• Saving generated images as files

Ask AI questions, generate code, and summarize text through 9Router using OpenAI or Anthropic request formats. Receive responses incrementally with streaming, and use provider combinations that automatically try another provider when needed.

• Ask an AI model questions through 9Router
• Generate code from written instructions
• Summarize text with a selected model

Transcribe audio files through 9Router using models from providers such as OpenAI, Groq, and Deepgram. Receive plain text, structured results with timestamps, or SRT and VTT subtitles, depending on the selected model’s support.

• Transcribing recorded meetings or interviews
• Creating SRT or VTT subtitles from audio
• Getting transcriptions with timestamps

Set up access to 9Router, a shared gateway for multiple AI providers, and discover available models. Find the relevant capability skills for chat, images, speech, embeddings, web search, and webpage retrieval.

• Configure a local or remote 9Router connection
• Check available models by capability
• Find instructions for image or speech tasks

Convert written text into speech through 9Router, choosing from multiple voice providers. Check available models and voices, then generate MP3 audio for narration, voiceovers, or reading text aloud.

• Creating narration from a script
• Turning written text into spoken audio
• Checking available voices before generating speech

Turn text into embeddings, numeric representations of meaning, through 9Router. Choose a model and process individual texts or batches to prepare data for meaning-based search, similarity comparisons, or RAG systems that retrieve reference material.

• Preparing text vectors for meaning-based search
• Generating embeddings for text similarity comparisons
• Batch-processing reference passages for RAG

Add OpenCode as an agent runtime in NanoClaw to use models from OpenAI, Google, OpenRouter, DeepSeek, and other supported services. The skill covers installation, authentication, group selection, and default model changes.

• Adding OpenCode to an existing NanoClaw installation
• Switching an agent group to OpenCode
• Changing the default model without signing in again

Move an existing OpenClaw setup to NanoClaw v2 through a guided conversation. Review identity, memory, credentials, groups, and scheduled tasks, then decide what to transfer and preview changes before applying them.

• Moving an existing OpenClaw setup to NanoClaw v2
• Transferring agent personality and stored memories
• Sorting credentials into their required storage locations

Let a NanoClaw container agent call local models running in Atomic Chat. The skill adds an MCP server, a connection that exposes model listing and text generation as tools, while Claude continues to coordinate the work.

• Delegate part of Claude's work to a local model
• List models available in Atomic Chat
• Generate an answer with a specified local model

Add Codex as the agent that plans tasks and coordinates tools in NanoClaw. Choose it for individual groups alongside Claude, with conversation history and session resume using a ChatGPT subscription or OpenAI API key.

• Adding Codex as a NanoClaw agent provider
• Choosing Claude or Codex for each group
• Setting up ChatGPT or API key authentication

Implement, update, test, or document TypeScript provider packages, the adapters connecting supported services and frameworks. This skill focuses on work under ts/packages/providers and directs the agent to read the provider workflow before making changes.

• Implement a TypeScript provider
• Modify a service or framework adapter
• Test provider-specific changes

Audit whether an AI agent follows its intended purpose, business rules, and permission boundaries. The skill guides setup discovery, test configuration, execution against an agent endpoint or substitute model, and interpretation of scores from selected judging models.

• Auditing an agent's compliance with business rules
• Testing permission boundaries and dangerous tools
• Evaluating an agent through its HTTP endpoint

Find and retrieve official OpenAI documentation to answer API integration questions with source evidence. Check endpoint definitions, parameters, and documented limits, and receive setup guidance when the documentation connection is unavailable.

• Verify specifications before integrating an OpenAI API
• Check endpoint parameters and schemas
• Support technical explanations with official documentation