A local web UI that introspects your coding-agent config, redacts secrets at capture, and builds a portable, composable Gem.

agentgem.ninemind.ai · browse the public marketplace at app.agentgem.ai (early testbed — hosted data may be reset)

AgentGem reads your coding-agent config — skills, MCP servers, and CLAUDE.md — redacts secrets the moment they're read, and produces a Gem: a manifest + lock archive you can publish to a GitHub-backed registry, merge with other Gems, and deploy to several targets. A browser can't read ~/.claude (it's sandboxed), so AgentGem runs a small server on your machine; secrets never leave your device — what crosses any boundary is a config shape with <redacted> in place of every sensitive value.

Built on AgentBack, ninemind's AI-native API/MCP framework: every operation is defined once as a Zod contract and exposed as a REST endpoint, an MCP tool, and an OpenAPI 3.1 document — so the web page and your local agent call exactly the same thing.

What it provides

• Secret-safe capture — redaction by value and by key name, before anything reaches a REST response, an MCP result, the live preview, or the built Gem.
• A neutral Gem source — a manifest + lock archive that isn't tied to any runtime. Build once; install into a local testbed, merge, publish, or compile to a target without re-reading raw config.
• Composition — the manifest/lock split lets small, focused Gems be reconciled into larger agents with a single re-resolved lock, not a pile of overlapping config.
• Workflow-aware recommendations — Analyze scans your agent's session history to see which skills, MCP servers, and hooks you actually use, and suggests ready-to-build Gems grouped by recurring workflow. It also distills brand-new draft skills from the procedures you repeat by hand — review them and fold them straight into a Gem.
• Cross-session recall — Recall searches across every past session by what happened inside it (an instant, local, secret-scrubbed index), then lets you chat with or extract across the ones that matter. Ranking is proven-use aware — artifacts with good downstream outcomes are boosted. The same intelligence is the agentgem-goldmine MCP server, so any coding agent can query your history.
• Memory-provider sync — the console's Memory panel bridges your recall index to external AI memory providers (mem0, supermemory): pull their memories in, and push scrubbed, consent-gated candidates out through a review outbox — nothing leaves without your approval.
• Context-hygiene detection — context hygiene grades each session for context bloat with LLM-free detectors, marks a deterministic "cut here at turn N", and — via agentgem warm --watch --nudge — raises a live OS notification when a running session's context gets heavy.
• Chat, and Play — Chat with a local coding agent from inside the console and distill the conversation into a Gem; Play builds AI-generated mini-games, sealed to run anywhere and versioned as first-class game Gems — publish them to the arcade, where they're installable, offline-playable PWAs searchable by genre and tag.
• Deploy targets — Eve and OpenAI Sandbox (code-gen), Flue (materialize, deployable to Cloudflare), and Bedrock AgentCore (managed backend); code-gen targets share a common compose step.
• Agent-to-agent (A2A) — export a Gem as an A2A Agent Card or a runnable A2A server so other agents can discover and call it.
• A native desktop app — a macOS/Windows/Linux build alongside the npx CLI, hosting the same local server in its own window.
• A GitHub-backed registry + public marketplace — publish, resolve, merge, and install composable Gems over the same archive format, and browse them at app.agentgem.ai. Publish a Gem Public, Unlisted, or Private, cut a new version or overwrite the current one, and gate a release behind group review (request review → a member installs it to test → an approval publishes). Rubrics are a first-class Gem type. Mini-apps are installable PWAs that play offline and are searchable by genre and tag. Every shareable link — a game, gem, @handle profile, or curated skill — unfurls with a branded preview card in Slack, X, or iMessage. The hosted marketplace is an early testbed: treat it as a preview, and expect accounts, stars, and reviews to be reset occasionally.
• Identity, profiles, and teams — sign in with GitHub, Google, or a passkey (better-auth under the hood); each account gets a tabbed /@handle profile hub (apps, reviews, orgs, groups). Create or join a group to share a private Gem with teammates or run peer review, and an org gets a scorecard, team-usage dashboard, and benchmark governance.
• Registry-free sharing & signing — agentgem get installs a published Gem with one command; agentgem send / receive pass one directly over an encrypted, one-time hand-off; agentgem verify checks a Gem runs across your local agents.
• An agent-native path — every operation is also an MCP tool, so your local agent can build Gems over /mcp with no browser involved.

A tour of the console

Quickstart

Needs Node.js ≥ 24. From the directory of the agent project you want to package, run it without installing:

npx @ninemind/agentgem         # npm
pnpm dlx @ninemind/agentgem    # pnpm

agentgem listening at http://127.0.0.1:4317
  UI:       http://127.0.0.1:4317/
  API:      http://127.0.0.1:4317/api/inventory  ·  POST http://127.0.0.1:4317/api/gem
  Explorer: http://127.0.0.1:4317/explorer/
  MCP:      http://127.0.0.1:4317/mcp

Open http://127.0.0.1:4317/, then:

1. Open a testbed — click Create / open testbed…. AgentGem detects the project you launched from (it has a .claude/.codex) and also lists ones from your Claude/Codex session history. Pick it and click Use this.
2. Pick artifacts — the project's skills / MCP servers / CLAUDE.md show on the left; Import from machine… pulls in global ones. Tick what you want, name the Gem.
3. Watch it seal — the live gem.json renders with every secret as <redacted>. Download it — that archive is what every target and the registry consume.

Prefer a persistent command? Install it globally:

npm install -g @ninemind/agentgem     # npm
pnpm add -g @ninemind/agentgem        # pnpm
agentgem --port 8080                  # honors $PORT; append ?dir=/path/to/.claude for another config

| Path | What it is | | ----------- | ------------------------------------------------------- | | / | The Gem Builder web UI | | /explorer | Swagger UI for the REST API (from the OpenAPI document) | | /mcp | The MCP endpoint — the same contract, for your agent |

From source

To hack on AgentGem, clone the repo. It's a pnpm project (npm works too), and AgentBack uses legacy decorators, so it builds with tsc then runs dist/:

pnpm install     # or: npm install
pnpm dev         # or: npm run dev   — build + start in one step
pnpm test        # or: npm test      — tsc -b && vitest run, against compiled dist/
pnpm clean       # or: npm run clean — rm -rf dist *.tsbuildinfo (run before re-testing after moves)

See CONTRIBUTING.md for the full workflow.

Desktop app

Prefer a double-click app over the CLI? AgentGem ships a native desktop build for macOS, Windows, and Linux — download it from Releases (a desktop-v* build). It runs the same core locally (in client mode) in its own window, adds a native folder picker, app menu, and system tray, and never sends secrets off your machine.

macOS builds are signed and notarized — Gatekeeper opens them normally. Windows and Linux builds are still unsigned: on Windows choose More info → Run anyway the first time.

To run or package it from source, see the desktop guide — in short, pnpm -C desktop dev to run, pnpm -C desktop dist to build installers.

Layering

Depends on AgentBack: @agentback/core (lifecycle), @agentback/rest + @agentback/rest-explorer (HTTP + Swagger UI), @agentback/mcp + @agentback/mcp-http (MCP over HTTP), and @agentback/openapi (the OpenAPI 3.1 document). The web UI, the REST API, and the MCP endpoint are three boundaries over one set of Zod contracts — src/index.ts wires them onto a single RestApplication.

For deeper reference, see docs/: getting started · desktop app · analyze · concepts · targets & deploy · GitHub App · A2A · registry.

License

MIT © ninemind.ai