Beacon Skills

Overview

Beacon Skills are Agent Skills that let an agent in any harness run Beacon’s cross-harness memory loop. An agent working in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, or another supported harness can use them to recall what earlier sessions learned about a repository. It can also turn a recent session into a reviewed lesson, and promote that lesson into a skill the whole team loads. Other Beacon Skills build local dashboard lenses, share traces and continue a local session in another runtime. The skills do not replace Beacon’s capture or review model. They tell the agent which beacon commands to run and when to stop and ask. They keep the person reviewing in control of every write to memory.

Skill	What it does	Network
`beacon-memory-recall`	Before a task, retrieves approved project memory relevant to it	None
`beacon-memory-distill`	Turns selected traces into reviewed memory: dry run, a consented evaluation, a lesson drafted from the source trace, approval by the user	Evaluator call only, after the user agrees
`beacon-memory-promote`	Installs an approved memory as a project Agent Skill	None
`beacon-lens-create`	Builds a lens for the local dashboard: reads the spec, inspects real trace data, writes, lints and previews the file with the user, then installs it	None
`beacon-trace-share`	Shares the current session as a trace on beacon.sh with `beacon share --current` and posts the link. Direct (link-only) by default, asks before public. Session sharing is a beacon.sh feature, documented at docs.beacon.sh	Uploads the session to beacon.sh, only when you ask
`beacon-session-handoff`	Finds a local session and continues it in another supported runtime through `beacon handoff`, using a detached terminal when the calling agent has no TTY	None

Requirements

The Beacon CLI on PATH, with endpoint capture installed so traces exist. See the quickstart.
For beacon-memory-distill only: an evaluator key in TYPESAFE_API_KEY or BEACON_JEV_API_KEY, or BEACON_JEV_ENDPOINT pointing at your organization’s compatible evaluator. Recall and promote need no key.
For beacon-trace-share only: a beacon login sign-in with the traces:write permission, or a Beacon API key in BEACON_API_KEY.

The plugin also registers Beacon’s local MCP server (beacon mcp serve) in harnesses that accept MCP servers from plugins. When the server is available, recall uses the get_memory_context tool. Otherwise it falls back to beacon memory list.

Install

The interactive beacon endpoint install installs the skills for every project unless you turn them off in the wizard. To do the same at any other time:

beacon skills install   # ~/.agents/skills, and ~/.claude/skills when Claude Code is set up

Beacon Skills also install from the asymptote-labs/agent-beacon repository. Most harnesses read its plugin marketplace directly:

Runtime	Install
Claude Code	`/plugin marketplace add asymptote-labs/agent-beacon`, then `/plugin install beacon@beacon`
Claude Cowork	Customize → Plugins → Add marketplace, then enter `asymptote-labs/agent-beacon`
Codex (CLI and desktop)	`codex plugin marketplace add asymptote-labs/agent-beacon`, then `codex plugin add beacon@beacon`
GitHub Copilot CLI	`copilot plugin marketplace add asymptote-labs/agent-beacon`, then `copilot plugin install beacon@beacon`
VS Code	Add `asymptote-labs/agent-beacon` to the `chat.plugins.marketplaces` setting, then install `beacon`
Cursor	An admin imports `https://github.com/asymptote-labs/agent-beacon` under Settings → Plugins → Team Marketplaces; users install `beacon` from Customize
Factory Droid	`droid plugin marketplace add asymptote-labs/agent-beacon`, then `droid plugin install beacon@beacon`
Grok Build	`grok plugin marketplace add asymptote-labs/agent-beacon`, then `grok plugin install beacon`
Devin CLI	`devin plugins install asymptote-labs/agent-beacon#agent-skills`
Qwen Code	`qwen extensions install asymptote-labs/agent-beacon:beacon`
Oh My Pi	`omp plugin marketplace add asymptote-labs/agent-beacon`, then `omp plugin install beacon@beacon`
OpenClaw	`openclaw plugins install beacon --marketplace asymptote-labs/agent-beacon`
Kimi Code	From a clone: `/plugins install ./agent-beacon/agent-skills`
Kiro	Powers → Add Custom Power → Import power from GitHub, then enter `https://github.com/asymptote-labs/agent-beacon/tree/main/agent-skills`
Pi	`pi install git:github.com/asymptote-labs/agent-beacon`
Prime Agent	`prime-agent package install git:github.com/asymptote-labs/agent-beacon`
Gemini CLI	`gemini skills install https://github.com/asymptote-labs/agent-beacon.git --path agent-skills/skills`
Hermes Agent	`hermes skills install asymptote-labs/agent-beacon/agent-skills/skills/<skill>` for each skill
Antigravity CLI, goose, OpenCode, OpenHands, and other skills-capable agents	`npx skills add asymptote-labs/agent-beacon`, optionally with `-a <agent>`
Cline	Copy `agent-skills/skills/*` into `.cline/skills`
DeepSeek Harness, Muse Code, Senpi	Copy `agent-skills/skills/*` into `.agents/skills`
fx	`/skills install asymptote-labs/agent-beacon`

Plugin installs also register Beacon’s local MCP server. Package, power, and skills installs add the skills only, and recall falls back to beacon memory list. In Claude Code the skills appear as /beacon:beacon-memory-recall, /beacon:beacon-memory-distill, /beacon:beacon-memory-promote, /beacon:beacon-lens-create, /beacon:beacon-trace-share and /beacon:beacon-session-handoff. Every harness also loads them on its own when a request matches.

Using the skills

You rarely name a skill. Each one describes when it applies, and the harness loads it when your request matches.

Recall before work

Starting a non-trivial task, or hitting a failure that might have a known fix, triggers beacon-memory-recall. The agent retrieves up to five approved memories for the current repository. When one changes what it does, it cites the memory’s ID. It treats memory as lessons from earlier sessions, not as policy. When a memory conflicts with your instructions or the repository’s docs, the agent follows you and the docs and says so.

Distill a session into memory

Ask something like “turn yesterday’s packaging fix into memory” or “review the Beacon memory candidates”. beacon-memory-distill then:

Selects the traces you named, or proposes a short list.
Runs beacon memory evaluations run --dry-run and shows the selection and estimated cost.
Asks before the evaluation call, and runs it only on the selection you approved.
Reads the source trace behind each candidate and drafts a lesson: title, kind, applicability, and body, each tied to the trace events that support it.
Shows every draft with a recommendation to approve, reject, or supersede, and records only the decisions you confirm.

Promote memory to a skill

Ask to “make this a skill”. beacon-memory-promote previews the generated skill, checks it for anything that should not be committed, and installs it at .agents/skills/<slug>/SKILL.md once you confirm. Committing it shares it with every teammate and every harness that reads .agents/skills.

Share a session

Ask to “share this session” or “publish this trace”. beacon-trace-share runs beacon share --current --harness <runtime> --json, which finds the session the agent is running in, and replies with the link. The trace is direct (anyone with the link) unless you ask for private; the agent asks you before making a trace public. When no session is found it lists candidates with beacon share --list, and when you are not signed in it asks you to run beacon login yourself.

Continue a session in another runtime

Ask to “handoff this session to Codex” or name another supported runtime. beacon-session-handoff lists local sessions when needed, resolves the requested destination and runs beacon handoff resume with detached launch so the interactive runtime receives a real terminal instead of inheriting the calling agent’s non-TTY command subprocess.

Why the agent writes the lesson

The evaluator returns probabilities, such as how likely the task succeeded and how likely the trace holds a reusable lesson. It does not return lesson text. On its own, an approved candidate would say only that no lesson text was extracted. beacon-memory-distill closes that gap. The agent reads the trace, writes the lesson, and you approve it with the reviewed text:

beacon memory candidates approve <candidate-id> \
  --title "Build the embedded hooks binary before running cli/beacon tests" \
  --kind workflow \
  --applicability "when running go test in cli/beacon on a fresh checkout" \
  --body-file lesson.md \
  --reason "reviewed against trace events 14-19"

The approved memory stores your text. The candidate keeps the evaluator’s original, so the review history shows what changed. See beacon memory for every flag.

Privacy and control

Nothing runs from hooks. The skills act only when an agent loads them in response to a request.
Two networked steps, both on request. The evaluation in beacon-memory-distill leaves the machine after a dry run and your explicit yes. It sends the bounded, redacted trace projection described in Jev evaluation. beacon-trace-share uploads the session you asked to share to beacon.sh, redacted, and never makes it public without asking.
Keys stay out of the chat. The agent checks whether a key is set without printing it, never asks you to paste one, and never passes it on the command line.
No silent writes. Approving, rejecting, superseding, and installing a skill each need your confirmation.
Memory is shared, so it stays clean. Lessons must not contain secrets, tokens, credentials, internal hostnames, customer data, or personal details, even when the trace does.

Publishing and source

The skills live in agent-skills/ in the Beacon repository. One skills/ directory serves every harness through its own manifest: .claude-plugin/plugin.json for Claude Code, an Agent Plugins plugin.json for Codex, Copilot, VS Code, Kiro, and Devin, .cursor-plugin/plugin.json for Cursor, kimi.plugin.json for Kimi Code, and gemini-extension.json for Gemini CLI. At the repository root, .claude-plugin/marketplace.json is the marketplace most harnesses read, .cursor-plugin/marketplace.json is Cursor’s, and package.json makes the repository a Pi and Prime Agent package. A test in the CLI checks every beacon command and flag the skills mention, so a change that renames one fails the same pull request.

Cross-harness memory

How traces become reviewed project memory.

beacon memory

Evaluate traces, review candidates, and install skills from the CLI.

beacon mcp

Serve approved memory to MCP clients.

beacon endpoint traces

Browse and search the traces the skills read.

Get Started

Deploy Asymptote

How Asymptote Works

Manage Asymptote

Agent Harness Integrations

For Security & IT Teams

Support

Contributing

Overview

Requirements

Install

Using the skills

Why the agent writes the lesson

Privacy and control

Publishing and source

Cross-harness memory

beacon memory

beacon mcp

beacon endpoint traces

​Overview

​Requirements

​Install

​Using the skills

​Why the agent writes the lesson

​Privacy and control

​Publishing and source

​Related

Cross-harness memory

beacon memory

beacon mcp

beacon endpoint traces

Overview

Requirements

Install

Using the skills

Why the agent writes the lesson

Privacy and control

Publishing and source

Related