Zephr
Start free

Governance · Connect

One command findsevery tool you already use.

Connect is the first five minutes: authenticate, pick a project, admit a scope, and let Zephr configure whichever coding clients are already on the machine. Every one of them then sees the same fixed tool contract.

Client adaptersTool contract enforced in CInpm publicationSDK integrations
How it works

Five steps, and the last one is a proof.

A setup flow that ends at “configuration written” has told you nothing. This one ends by writing a memory and reading it back through the client it just configured.

  1. Step 1

    Get the command-line interface

    The designed path is a single command. It is not published to the registry yet, so today you build it from a checkout — the commands underneath are identical either way.

  2. Step 2

    Authenticate through the device flow

    The terminal shows a code, the browser approves it, and credentials land locally with an expiry. No password is typed into a command-line prompt.

  3. Step 3

    Detect and import the clients present

    Each supported client has a config dialect. Connect parses what is there, imports it into a profile, and records the source of every entry.

  4. Step 4

    Admit the scope explicitly

    A project, a repository, a worktree — and, if you want code intelligence, an explicit consent for indexing. Nothing is inferred and nothing is opted in by default.

  5. Step 5

    Prove it with a real recall

    The run does not report success on configuration alone. It writes a memory and reads it back, so the first thing you see is the loop actually closing.

The artifact

The command, and what it finds.

Here is the entry point exactly as designed, the honest state of its distribution, and the detection result it produces on a machine with three coding clients installed.

Connect · entry pointNot published

The golden path command

This is the designed entry point. The package is not on the public registry yet, so the one-liner below does not resolve today — it is shown because it is the contract we are building toward, not because it works.

npx zephr connect

Working path today — build from source

git clone https://github.com/DigitalSoftDistribution/zephr.git
cd zephr
pnpm install --frozen-lockfile
pnpm --filter @zephr/protocol build && pnpm --filter @zephr/core build
pnpm --filter @zephr/mcp-server build && pnpm --filter @zephr/mcp build
Requires
Node.js 24.x and pnpm
Proven on
linux · x64 — the only platform continuous integration runs
npm publication not shippedbuild from source today
Connect · detectionVerified

Three clients found on this machine

Each client keeps its configuration in a different dialect. Connect reads them, does not guess at anything it cannot parse, and records where every imported entry came from.

  • Claude CodeJSON · mcpServers · imported_claude_codeAdapter shipped
  • CursorJSON · mcpServers · imported_cursorAdapter shipped
  • CodexTOML · mcp_servers · imported_codexAdapter shipped
  • opencodeJSON · mcp · imported_otherConformance in progress
imported into one profile
Connect · commands

What the interface actually exposes

  • zephr connectCold start: auth, project, admission, MCP config, recall
  • zephr loginAuthenticate through the RFC 8628 device flow
  • zephr statusShow connection and active role state
  • zephr healthCheck the daemon and the MCP handshake
  • zephr recallRun a recall against your memories from the terminal
real commands · from the shipped source

Illustrative example — not live data

The contract

Every client sees the same tools.

The tool surface is versioned and tiered, and its shape is checked in continuous integration: tier membership, per-tool descriptor hashes, and byte budgets. A tool cannot quietly appear, change signature, or grow past its budget between releases.

  • coreNames frozen

    remember · recall · why · verify · session · rules · status · admin

    Eight frozen names under a serialized schema budget. Served remotely in cloud mode, over local stdio in local-only mode.

  • searchHosted plane evolving

    grep · lsp · search

    Mode-dependent. Results always disclose which plane served them, at which ref and generation.

  • docsShipped

    docs

    Full catalog in cloud mode; project-local docs only in local mode, with honest degraded states.

  • reviewReserved

    reserved

    Reserved tier. It activates through a contract minor-version bump, not by silently appearing in a tools list.

Management tools are deliberately absent from the agent surface. Administration belongs to the API, the command line, and the dashboard — not to something an agent can call.

What Connect does

Every capability, with its real state.

Distribution and the SDK are the two honest gaps here, and they are the two things a landing page is most tempted to overstate. They are badged as what they are.

  • First-run client detection

    Shipped

    Connect reads the config dialects of the clients already installed, imports what it finds into a profile, and records where each entry came from.

  • Device-flow authentication

    Shipped

    Authentication is an RFC 8628 device flow: a code on the terminal, approval in the browser, and credentials that expire and refresh.

  • Scope admission during setup

    Shipped

    The first run creates or selects a project and requests admission for the repository and worktree before a single tool call is made.

  • Fixed, tiered tool contract

    Shipped

    Tier membership, per-tool descriptor hashes, and byte budgets are enforced in continuous integration, so the contract is a checked artifact rather than a promise.

  • npm distribution

    Not yet published

    The command-line interface is real and its commands work from a built checkout. It is not on the public registry yet, so the one-liner is the designed path, not a working one.

  • Platform matrix

    Linux x64 proven

    Continuous integration runs on Linux x64 only. Binaries are packaged upstream for macOS and Windows, but they are not claimed as supported until a runner proves them.

  • SDK entry points

    Paused

    One TypeScript SDK generated from the API schema is the plan. Framework integrations stay paused until that API exists — a client pointed at an endpoint nobody implements is not an integration.

  • Integration marketplace

    Planned

    Integrations are pull-driven: none starts before three design partners ask for it, and none is listed before it round-trips against the real API in continuous integration.

Start where the tools already are.

Walk the full golden path step by step, or read the install documentation for the build-from-source route that works today.

Walk the golden pathInstall docs