Local Agent Toolkit
jnMetaCode/local-agent-toolkit
Memória, skills e tracing para agentes IA — 100% local, zero cloud
Ver no GitHubToolkit MCP-nativo para construir agentes IA com foco em privacidade local. Composto por três ferramentas: engram (memória persistente com busca semântica), skillet (gerenciador de skills de agentes via registro Git) e tracelet (rastreamento e debugging em tempo real via OpenTelemetry). Tudo roda na sua máquina, sem dependências externas.
Instalação
npx convez-ai jnMetaCode/local-agent-toolkit1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Construir agentes IA com memória persistente e offline
- Gerenciar e compartilhar skills entre projetos de agentes
- Debugar e monitorar execução de agentes em tempo real
- Trabalhar com dados sensíveis sem enviar para serviços cloud
Veredito

Toolkit sólido e bem pensado para devs que querem construir agentes IA com privacidade e controle total. A combinação das três ferramentas (memory + skills + tracing) é coerente e reduz a fricção de setup; foco em local-first e zero-dependency é diferencial legítimo. Vale explorar para workflows que exigem dados privados ou ambientes offline.
README
A tradução para o português deste README ainda está na fila.
🛠️ A local-first, MCP-native toolkit for building AI agents
Three small, zero-dependency, npx-first tools that give your agent memory,
skills, and eyes — without shipping your data to anyone's cloud.
npx @jnmetacode/engram · npx @jnmetacode/skillet · npx @jnmetacode/tracelet
English | 简体中文
Most AI-agent tooling in 2026 wants you to sign up, install an SDK, and send your prompts, notes, and traces to a hosted service. These three tools take the opposite stance: everything runs on your machine, nothing leaves it, and there's nothing to install beyond one command. Each is pure Node built-ins (zero runtime dependencies), MIT-licensed, framework-agnostic, and tested across Node 18/20/22 on Linux/macOS/Windows.
They fit together (see the end-to-end recipe) but each stands alone. And the memory + skills layers are MCP-native — usable directly from Claude Code / Claude Desktop, not just the CLI.
node demo/recipe.mjs # one agent run: a skill (skillet) + memory (engram) + tracing (tracelet), all local
The toolkit
🧠 engram — a local, private memory layer
Index your notes, files, PDFs and EPUBs, then recall anything with
citations and temporal reasoning (recency-aware ranking, --since week)
— 100% on your machine. A built-in BM25 engine works offline; optional local
Ollama adds semantic recall. Recall is self-improving — confirm an answer
(engram reinforce) and similar queries rank it higher. engram watch keeps it
live as you edit; an MCP server lets any agent recall, remember and
reinforce.
npx @jnmetacode/engram watch ~/notes # live memory; then: npx @jnmetacode/engram recall "what did I decide about pricing"
🍳 skillet — a package manager for AI agent skills
Find, install, version and share SKILL.md skills from a Git-backed registry
(a JSON file in a repo — no server). Installs copy the skill into your project and
pin the commit SHA. 30 verified skills seeded (incl. curated Chinese skills from superpowers-zh); a static gallery and an
MCP server let an agent find and install skills for itself.
npx @jnmetacode/skillet search pdf && npx @jnmetacode/skillet add pdf
🔭 tracelet — local DevTools for AI agents
Point any OpenTelemetry exporter at localhost:4318 and watch your agent's
execution tree stream in live — LLM calls, tool calls, prompts, tokens,
latency, errors, and cost estimates per model. Ingests both OTLP protobuf
(the exporter default) and JSON; opt-in --persist keeps history across
restarts. No account, no Docker, no Python.
npx @jnmetacode/tracelet
How they fit together
🧠 engram 🍳 skillet 🔭 tracelet
gives your agent installs new shows you what the
(and you) memory → skills into it → agent actually did
(recall + MCP) (registry + gallery) (live OTLP traces)
Build an agent, give it memory (engram), teach it skills (skillet), and debug what it does (tracelet) — all locally.
Install as a Claude Code plugin (one command)
This repo doubles as a plugin marketplace. Inside Claude Code:
/plugin marketplace add jnMetaCode/local-agent-toolkit
/plugin install local-agent-toolkit@local-agent-toolkit
That gives the agent the engram MCP tools (engram_recall /
engram_remember — durable local memory) and the skillet MCP tools
(skillet_search / skillet_install — find and add skills for itself), plus
two bundled skills that teach it when to use them (engram-memory,
tracelet-instrument). Run npx @jnmetacode/tracelet in a terminal to watch
what it does. Everything stays on your machine.
Shared principles
- Local-first & private — your data never leaves your machine.
- Zero runtime dependencies — pure Node built-ins;
npx <tool>and go. - Framework-agnostic & standards-based — OpenTelemetry, the open
SKILL.mdformat, the Model Context Protocol. No lock-in. - MCP-native — engram and skillet run as MCP servers, so they're usable directly inside Claude Code / Claude Desktop, not just the CLI.
- Small & readable — each is a few hundred lines you can audit in minutes.
- Tested — every tool has a CI matrix and a real test suite.
- MIT licensed.
Repos
Each tool lives in its own repo and is published independently:
| Tool | What it does | Repo |
|---|---|---|
| 🧠 engram | local private memory — watch mode + MCP server | jnMetaCode/engram |
| 🍳 skillet | agent-skills package manager — gallery + MCP server | jnMetaCode/skillet |
| 🔭 tracelet | local DevTools for agent traces — OTLP protobuf+JSON | jnMetaCode/tracelet |
| ▶️ demo | one-command recipe proving all three together | ./demo |
Status: actively shipped (engram 0.3.x, skillet 0.1.x, tracelet 0.2.x), all functional and tested. See each repo's README and its
docs/LAUNCH.mdfor what's next.