signet.Try the preview

For builders / Getting started

Turn everyday rules
into personal authority.

Signet is Jeremy McEntire’s proposal for personal authority across services. Source foundations and a local research prototype are preserved; further development is paused. Conversational rule setting, live purchasing and controlled-browser enforcement are not connected. Read the complete concept before evaluating the prototype.

The later native owner path connects passkey state and rings through one JSON CAS aggregate. Synthetic service tests pass; native browser/HTTP/concurrency review and readable requirement binding remain. The KMS transport is mock-tested, not live. See the precise implementation checkpoint and open work.

Start with the read-only agent preview.

From a checkout containing this change, run:

cargo build --locked -p signet
./target/debug/signet preview-serve

The preview exposes standard MCP discovery and tool calls for hypothetical purchases and exact rule-change proposals. It never opens a vault, issues a grant, changes a rule, or makes a purchase. This command becomes available through remote installation only after this revision is published.

Read the agent preview protocol, everyday authority contract, and platform readiness matrix.

Exercise the persistent authority core.

The source now includes owner-signature verification, versioned rules, atomic single-use grants, executor reservations, and receipt-backed reorder baselines. Run cargo run --locked -p signet --example authority_walkthrough for a synthetic end-to-end contract exercise.

Read the authority service contract and deployment gates. A passkey-backed owner approval app and signed HTTP/MCP adapter are implemented locally. Protected deployment, real-device validation and merchant adapters remain. A same-user CLI or model-provided approval flag is not owner authentication. No vendor account is connected by this walkthrough.

Try the owner approval experience.

./target/debug/signet owner-preview --port 4322

Open http://localhost:4322 to review an exact purchase, compare a rule change, and explore backup passkeys. This explicitly fictional preview loads no credentials and grants no access. The local verification path uses server-verified WebAuthn and an injected signer; production isolation remains unverified. Read the owner app contract and deployment gates.

Explore the existing vault components.

The following steps inspect the separate legacy vault runtime. Its proof/query paths and standard MCP interoperability remain incomplete. Use synthetic data and a separate development configuration.

01. Install from source.

Use Rust 1.88 or later and Git. The --locked flag uses the repository's tested dependency versions. The vault CLI is installed from this repository; cargo install signet is not the installation command for this project.

cargo install --locked --git https://github.com/jmcentire/signet.git signet

02. Initialize a local vault.

signet init
signet vault-status

Follow the initialization instructions and keep recovery material private. To inspect available commands, run signet --help.

03. Connect the read-only MCP preview.

Add the separate read-only preview to your client's MCP server configuration. For Claude Desktop, this entry belongs in claude_desktop_config.json. The client must be able to find the installed binary; use its absolute path if needed.

{
  "mcpServers": {
    "signet": {
      "command": "signet",
      "args": ["preview-serve"]
    }
  }
}

Restart the client after saving the configuration. The repository setup guide covers configuration and troubleshooting.

The integration path.

Standing permission, conditional reorders, action exceptions, and one-time rule-management authority need distinct enforcement. The user authenticates and confirms the exact change; an agent-supplied approval flag is never enough.

A personal-agent platform supplies the conversation, model, service connectors, and consent experience. Signet supplies components for the authority boundary. MCP is the connection surface; it does not establish trust by itself.

  1. Evaluate locally. Run the read-only MCP preview and synthetic authority walkthrough. Inspect the schemas and use only temporary test identities.
  2. Map authority. Decide which facts can be proved, which context is agent-internal, and which actions need explicit permission. Review every transport and enforcement path.
  3. Complete the integration. Review the passkey owner app on real devices, establish isolated service custody, and add an authenticated merchant executor with idempotency and reconciliation.

Use the isolated evaluation walkthrough and integration guide for humans and agents. Platform integrations are proposed work; no personal-agent platform partnership or endorsement is claimed.

Understand the current boundary.

The MCP get_proof executor currently returns deterministic placeholder bytes, not a cryptographic proof. Tier 1 and Tier 2 query responses are scaffolding. Do not use them as evidence of eligibility, identity, or real personal reasoning.

The authenticated middleware pipeline exists, but direct JSON-RPC dispatch has separate paths, including an anonymous session for some tools. Review transport and enforcement wiring; do not assume every exposed request passes through the full pipeline.

Exact-context capability verification exists in the credential crate. MCP and SDK capability issuance currently fail closed; verified issuer wiring remains to be implemented, and generic one-time capabilities remain disabled until a consumption ledger is available. Installing Signet does not enable production payment custody.

Read the capability verification boundary, security policy, and contributor guide.

Looking for agent tool policy?

Signet Eval is the separate tool-call policy engine maintained by Wander. Its installation and configuration are independent of the vault.

cargo install signet-eval