You Already Have Dozens of Agent Skills. You Just Can't Find Them.

Source: Dev.to

Managing a Growing Skill Collection with akm

In the last post I explained the problem: your agent’s skill collection is expanding faster than you can manage it. Skills are scattered across directories, there’s no search, no sharing, and sanity is slipping.

Agentikit solves this with a single CLI – akm – that gives your agent a searchable, indexed stash of assets.

The Real Challenge

Most of you aren’t starting from scratch. You already have assets spread across multiple tools:

You may be using two or three of these platforms in the same week, and none of them can see each other.

akm doesn’t care where the assets originated. Point it at any directory and it indexes everything inside. Point it at five directories and you get semantic search across all of them – one command, every platform, every model.

Quick Start

Install the CLI

After installation, akm is on your PATH. When a new version drops, run akm upgrade to update in‑place.

Initialise a Stash

akm init

• Creates ~/akm with sub‑folders: scripts/, skills/, commands/, agents/, knowledge/, memories/.
• To use a different location, set AKM_STASH_DIR before running akm init.

Adding Existing Asset Directories

Instead of moving files around, simply register the directories you already use.

# Register Claude Code skills
akm stash add ~/.claude/skills

# Register OpenCode assets in a project
akm stash add ./my-project/.opencode/skills

# Register Cursor rules
akm stash add ./.cursor/rules

Naming Sources (Optional)

akm stash add ~/.claude/skills --name "claude-skills"
akm stash add ./team-shared --name "team"

List / Remove Sources

# Show everything you’ve added
akm stash list

# Remove by path or name
akm stash remove ~/.claude/skills
# or
akm stash remove claude-skills

Installing Remote Kits

You can pull in assets from GitHub, npm, or a local git repo. The kit is cached and indexed automatically.

# A team repo full of shared skills
akm add github:your-org/team-agent-toolkit

# An npm package
akm add @scope/deploy-skills

# A local git directory
akm add ./path/to/my-opencode-skills

Building the Search Index

# First‑time full build
akm index

# Subsequent incremental builds (only changed dirs)
akm index

Enable Vector‑Based Semantic Search (optional)

# Pull an embedding model (e.g., Ollama)
ollama pull nomic-embed-text

# Configure the embedding endpoint
akm config set embedding '{"endpoint":"http://localhost:11434/v1/embeddings","model":"nomic-embed-text","dimension":384}'

# Re‑build the index with embeddings
akm index --full

If you don’t configure embeddings, akm falls back to robust keyword matching.

Searching Your Assets

# Search across all registered sources
akm search "docker container management"

The command returns references you can feed directly back to akm:

# Show the full content of a skill
akm show skill:docker-homelab

• Skills → full SKILL.md content.
• Scripts → runnable command.
• Commands → markdown template with placeholders.
• Knowledge → navigable sections with TOC.

Search Community Registries Too

akm search "code review" --source both

Install a Found Kit

akm add github:someone/great-kit

Clone a Single Asset from a Kit

akm clone "github:someone/great-kit//skill:code-review" --dest ./.claude

The appropriate sub‑directory (skills/, scripts/, etc.) is created automatically.

Putting It All Together

Add a snippet like the one below to your AGENTS.md, CLAUDE.md, or system prompt so your agent can leverage the stash directly:

## Agent Stash Access

You can retrieve any asset with the `akm` CLI:

- **Search**: `akm search ""`
- **Show**: `akm show :`
- **Run a script**: `akm run `
- **Add a kit**: `akm add `

Now you have a single source of truth for all your skills, scripts, commands, agents, knowledge, and memories—no matter where they originally lived. Happy building!

Resources & Capabilities

You have access to a searchable library of scripts, skills, commands, agents, knowledge, and memories via the akm CLI.
Run akm -h for a full list of options.

The Problem

• Each agent platform (Claude Code, OpenCode, Cursor, etc.) stores its assets in its own format and location.
• When you need a specific script or rule, you end up hunting through multiple directories or repositories.
• This fragmentation makes it hard to keep context clean and to reuse assets across tools.

How akm Solves It

akm indexes all of your asset locations in one place, letting any model that can run shell commands search across them with a single query.

• Progressive disclosure – the agent only loads the files it actually needs.
• Relevance ranking – results are ordered by how well they match the query.
• Platform‑agnostic – Claude Code skills stay Claude Code skills, OpenCode scripts stay OpenCode scripts, etc.; akm merely makes them discoverable.

Example Setup

Assume the following directories contain your assets:

1. Install akm

curl -fsSL https://raw.githubusercontent.com/itlackey/agentikit/main/install.sh | bash

2. Initialise the index

akm init

3. Add your asset locations (stashes)

akm stash add ~/.claude/skills
akm stash add .opencode/skills
akm stash add .cursor/rules
akm add github:your-org/team-agent-toolkit   # remote repo

4. Build the index

akm index

5. Search for what you need

akm search "deploy container to azure"

Result: akm returns the Azure deployment script from the OpenCode directory, the Docker skill from the team repo, and any relevant knowledge doc from Cursor’s rules—all ranked by relevance. The agent then loads only the selected files and proceeds with its task.

Benefits at a Glance

Quick Reference

Repository:

Give it a try with your scattered agent assets, and let us know if anything breaks!