KELYRA launch: CLI first, public console watch-only, holder access next. Watch Console
kelyra 
██╗  ██╗███████╗██╗  ██╗   ██╗██████╗  █████╗
██║ ██╔╝██╔════╝██║  ╚██╗ ██╔╝██╔══██╗██╔══██╗
█████╔╝ █████╗  ██║   ╚████╔╝ ██████╔╝███████║
██╔═██╗ ██╔══╝  ██║    ╚██╔╝  ██╔══██╗██╔══██║
██║  ██╗███████╗███████╗██║   ██║  ██║██║  ██║
╚═╝  ╚═╝╚══════╝╚══════╝╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝

The execution layer for agents that need proof.

Kelyra combines a local CLI, SWD verification, policy gates, proof bundles, and a watch-only console preview before token-holder access opens.

Watch Console Protocol
kelyra -- ~/project

$ kelyra swd apply --stdin --json

✔ Verified: PATCH src/auth.ts

✔ Receipt saved: swd-20260526-8f1c2a

$ kelyra proof share swd-20260526-8f1c2a

Verification demo

The part worth showing is the proof layer.

Kelyra does not ask reviewers to trust a model narrative. It turns each file edit into a claim, checks it against disk state, and records the outcome.

Normal edit

A matching file action finishes with proof.

The model proposes a PATCH, SWD applies it, hashes the result, and saves a receipt.

Claim
PATCH src/auth.ts
Check
intent and hash matched
Outcome
receipt created
── SWD Verification ──
✔ Verified: PATCH src/auth.ts
✔ Receipt: swd-20260526-8f1c2a
Tokens: 4,812 total via anthropic
Budget: 4,812/500k · 1/3 turns · ~$0.024

Mismatch

Bad claims are sent back for repair.

If the model claims a write that did not happen, Kelyra returns actual state instead of accepting the story.

Claim
MODIFY README.md
Check
content hash drift
Outcome
correction turn
✖ Verification failed
Expected: 9b2d3c1a
Actual:   44f0aa91

Correction turn:
The file differs from your declared CONTENT_HASH.
Re-read README.md and submit a corrected FILE_ACTION.

Policy gate

Risky paths are stopped before disk writes.

Sensitive files and command surfaces are blocked or require explicit opt-in, even for external agents.

Claim
CREATE .env
Check
sensitive path
Outcome
write blocked
{
  "ok": false,
  "rejected": [{
    "path": ".env",
    "risk": "block",
    "reason": "Sensitive file writes are blocked"
  }]
}

Entry points

Choose the path that matches your workflow.

Kelyra can run the agent, learn repo rules, or act as the verified file-edit boundary for another agent.

Use Kelyra as the agent

Run one task or open chat

For developers who want Kelyra to call a configured provider and verify every file edit.

kelyra init
kelyra run "explain this repo"
Teach Kelyra your repo

Generate and load skills

For teams that want repo rules, review expectations, and risk surfaces active every session.

kelyra learn
kelyra run --file TASK.md -s repo
Connect another agent

Use Kelyra over MCP

For MCP clients or external agents that need dry-runs, verified applies, rollback, and receipts.

kelyra mcp
swd_dry_run / swd_apply
Operate the proof workflow

Diagnose, explain, and publish

For teams that need local readiness checks, CI failure explanations, static proof pages, and hosted receipt history.

kelyra doctor
kelyra ci explain

Proof first

Every claimed edit becomes reviewable evidence.

Kelyra snapshots the filesystem before and after model output, verifies the declared action, records the result, and exports a bundle reviewers can inspect without trusting a chat transcript.

01

Strict Write Discipline

Models must declare file actions. Kelyra checks disk reality before accepting the result.

02

Signed Receipts

Each verified run records hashes, provider, branch, policy, and chain context.

03

Policy Gates

Teams can require signatures, block risky paths, and enforce receipt-backed changes in CI.

04

Shareable Proof

Portable proof bundles and static HTML pages expose file status, integrity, signature state, chain state, and diffs.

How it works

One verified path for agent writes.

1

Agent proposes actions

Use Kelyra chat/run, MCP, or external-agent JSON and FILE_ACTION output.

2

Boundary validates

Paths are constrained, sensitive files are blocked, and policy is loaded.

3

SWD verifies disk

The engine snapshots before and after state, hashes files, and rolls back failed writes.

4

Receipts keep record

Successful writes produce local receipts, proof bundles, share pages, and CI-verifiable evidence.

Watch-only proof mode KELYRA holder access pending
Fix the token rotation bug in src/auth.ts and prove the change.
I found the unsafe reuse path. I will patch the rotation flow and verify the write before saving a receipt.
PATCH src/auth.ts
Status verified
Receipt swd-8f1c2a
Holder-gated chat opens after launch...

Console surface

Console launches as a watch-only product surface.

The CLI stays useful without accounts or tokens. Kelyra Console first ships as a public preview for the proof workflow, then unlocks hosted chat, Pulse, Forge, and receipt history for KELYRA token holders.

Access model

Two surfaces, one protocol.

Kelyra Core

Open-source CLI for local SWD verification, receipts, policy checks, proof sharing, diagnostics, and CI gates.

  • No wallet required
  • Bring your own provider key
  • Works with external agents
  • Explains CI failures locally

Kelyra Console

Public watch-only preview first; token-holder workspace for proof chat, hosted jobs, quota-aware app tools, and receipt history next.

  • Launch preview is read-only
  • Holder-gated hosted proof history
  • Fresh/full quota tracking after gate activation
Core Open protocol engine
Console Watch-only now, holder chat next
Teams Policy, CI, attestations

Quick start

Run Kelyra locally first.

npm install -g kelyra
kelyra doctor
kelyra providers check
kelyra console