Beam logoBeam

Beam Documentation

Local-first design intelligence for coding agents.

Beam is an open-source bridge that turns Figma frames into structured implementation context, rendered references, assets, tokens, snapshots, evidence, and visual comparison signals.

This page explains the product model and the order in which the documentation should be read. It intentionally avoids becoming the installation guide, command reference, or architecture specification.

Beam's job is to make design handoff inspectable. It does not replace Figma, does not write application code for you, and does not require Beam Cloud for the local Free workflow.

Read this page first if you need the mental model. Move to Install Beam when you are ready to run commands.

  • Not an IDE, code generator, or design editor.
  • Built for local Free usage first.
  • CLI and MCP use the same core engine.

What Beam Does

Beam sits between Figma and a coding agent. The user gives Beam a Figma frame URL, and Beam converts that design into a local bundle of implementation context: a simplified frame model, rendered reference image, assets, token hints, warnings, confidence signals, and file paths the agent can open.

The important shift is that the agent no longer starts from a screenshot alone. A screenshot shows pixels, but it does not explain node names, text layers, component intent, exportable assets, omitted fields, cache state, or whether the design data is reliable enough to build from. Beam makes those things explicit.

  • Use Beam when a developer or agent needs to implement a Figma frame.
  • Use Beam when a team wants local, inspectable design handoff artifacts.
  • Use Beam when visual comparison needs a repeatable Figma reference.
  • Do not use Beam as a Figma editor, browser IDE, or framework-specific code generator.

Recommended Reading Order

The documentation is ordered by how a user adopts Beam. Start with the product model, then install the local tool, then inspect a design, then connect an agent, and only then read deeper reference pages.

Each page owns one stage of the journey. If a later page needs setup knowledge, it links back conceptually instead of repeating all setup instructions.

  • Introduction: understand what Beam is and when to use it.
  • Install Beam: prepare Node.js, install the package, authenticate, and run doctor.
  • First Inspect: run the first Figma frame inspection and read the output.
  • Agent Setup: connect Beam to an MCP-compatible coding agent.
  • CLI Commands: use the command index when you need exact syntax.
  • Architecture and Business: understand system boundaries, security, rate limits, and editions.

Core Objects

Beam documentation uses a few repeated nouns. They appear throughout the product, so this page defines them once before the operational guides begin.

A frame is the Figma surface the user wants to build. A brief is Beam's simplified implementation context. A snapshot is the durable local record of a fetched design. An asset manifest is the index of exported files. A compare result is the visual check between Figma and a local page.

  • Frame: the Figma node Beam targets.
  • Brief: the implementation summary Beam returns.
  • Snapshot: a reusable local record of a design fetch.
  • Asset manifest: a structured list of exported images, vectors, and paths.
  • Evidence: what Beam knows, inferred, or still needs from the user.
  • Compare result: local visual fidelity feedback against Figma ground truth.

Local-First Boundary

Beam Free runs locally. Credentials stay in the user's Beam directory, design artifacts are written to local .beam paths, and coding agents connect through a local MCP server. Beam Cloud is an optional future control plane for sync, sharing, history, and governance.

This boundary is important because teams need to know which data is local, which data is customer design data, and which future features would require explicit cloud sync.

Human And Agent Surfaces

Beam has two primary surfaces. Humans use the CLI to log in, inspect, export, compare, list snapshots, maintain mappings, and create debug bundles. Agents use MCP tools to request the same core context without duplicating Figma or cache logic.

The CLI and MCP server are intentionally thin over Beam Core. That keeps behavior consistent whether a developer runs beam inspect or an agent calls get_design_context.