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

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"

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

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

   🧠 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.

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.

• 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.md format, 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.

Each tool lives in its own repo and is published independently:

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.md for what's next.