In Development
Orbyt Launch Keys
Agents Can Sign. Only You Can Choose.
Your agents ask. You decide. In development.
A key can sign without you. Today a signature proves verified key use, not that you chose. Here is where it stands.
Why does an AI agent need human approval?
Designed
Launch Keys is a way for a person to approve, deny or stop AI agents from an iPhone or a Mac. It is in development and not available. A digital signature shows a key was used. It does not show a person chose. That gap is what Launch Keys is being built for.
One action, one word: the apps call it Stop.
Until , the founder's signing key had no passphrase, so an agent session could sign as him. The Machine, the AI agents that run Orbyt Labs, can check that his key signed, never that he chose. Today a signature proves verified key use, and only that. His key asks for Touch ID, so his presence is a fair inference. A signature does not prove it. No recorded approval has been signed through Launch Keys yet.
Measured
The founder runs Orbyt Labs with the Machine, a team of AI agents that work as its leadership. Each day the Machine checks for a commit signed by his key. The key he used to sign with had no passphrase. Any process running as him could sign as him, an agent session included. So a signature could land on work he never saw. That key was revoked on . On , a key that stays in his Mac's Secure Enclave, the part of Apple's chip that by design never lets a key out, and asks for Touch ID took its place. The daily check is the Machine's dead-man switch: if 14 days pass with no commit signed by his key, promotions pause where they are.
Measured
Founder-key liveness reads true: the Machine's daily check found a commit signed by the founder's key within its window. It last ran on . Whatever it reads, it measures verified key use. It never shows that he was there, or that he chose.
Designed
Launch Keys starts there. It is being built for the founder first, and designed so a larger organization would use it without a rewrite. The problem it takes on is narrow: tell one person's decision about one request apart from an agent that can reach a key.
“this is being built just for Orbyt Labs to start with”
The reading comes from the daily check's state record, which is not public. The daily pulse republishes it in pulse.json as true or false, and publishes false when the check could not look. The window, 14 days, is the check's own rule. The wording, a commit signed by the founder's key, is D-0095, . The missing passphrase is the founder's key record's own reason for the revocation, dated the day of it. That record's other fields stay private.
- Measured
- Read from a committed record each time the site builds.
- Designed
- What the project's decisions say Launch Keys would do. Not shown working.
- Coded and tested against fixtures, not on a device
- In the project's code, with tests against sample inputs, as its decision record says. Not run on a phone or a Mac.
- Probed on a device
- A dated test on one device, with what it did not settle.
- Not yet
- Unfinished, as of the date beside it.
What does a signed commit prove, and what does it not?
A signature on the Machine can be read three ways, and only the first is proved. Verified key use: the signature checks against the pinned key. Inferred presence: the key is set up so the founder was probably there. Recorded approval: a person read one request and chose. They are easy to blur. Launch Keys exists for the difference.
| Reading | What it means | Proved by a signature? | Since |
|---|---|---|---|
| Verified key use | A signature checks against the pinned key. | Yes. It is the only thing a signature proves. The standing ruling is D-0030, an accepted risk. | Ruled |
| Inferred presence | The founder's current key is set to stay in the Secure Enclave of his Mac and to ask for Touch ID, so it is fair to infer he was there when it signed. | No. A signature does not prove it. The Machine checks only which key signed, and a signature from this key carries no record of a touch. The recorded ruling does not count it as proof, and the inference does not reach the backup key the record also names. | Current key pinned |
| Recorded approval | A person read one request and chose, and the choice is signed and kept. | Not yet. Launch Keys is designed for it, and no real approval has been signed through it. | Not established as of |
The ruling is D-0030 in the decision ledger, : “Signing proves key custody, not personal presence: an accepted risk.” The key record also names a backup key, pinned and drilled . An outside draft draws the same line for agent actions: its signed receipt “does not, by itself, prove that the holder of that identifier is a particular natural person” (Authorization Receipts for High-Risk Agent Actions, revision 13, an active individual Internet-Draft, not a standard).
How would a person approve an AI agent's action?
Coded and tested against fixtures, not on a device
The approval screen is built from the verified request, and a property test reads the screen back into exactly the signed parameters. Invisible characters show as visible markers.
Designed
The agent's own note would appear only under an “Agent says” label, and it would never build the title. Characters that change the direction of text would show as visible markers too.
Approve and deny would be separate acts. Each would happen on a screen that shows one request in full. Each would need its own fresh Face ID or Touch ID, and the prompt would name the decision. Unlocking the app would not count, and nothing would approve more than one request at once. The keys would be created so they refuse to sign without that fresh check.
Not yet
The fresh check for each decision is not yet verified on a device. The project's own record lists it as still to verify.
Designed
Each decision would be signed twice on the device: once with ECDSA P-256 in the Secure Enclave, and once with ML-DSA-87, a post-quantum signature algorithm specified in FIPS 204. Both signatures would be required, over a SHA-384 digest, and any organization that would use it would use the same suite. ML-DSA-87 is a post-quantum algorithm. P-256 is not.
A request that is not decided in time would be denied.
From the project's decisions recorded , and , and the fixes its decision record lists on . These are design decisions and code tested against sample inputs, not a working approval.
How would Launch Keys stop AI agents?
Measured
Today a halt is a file. The Machine's halt workflow commits it when the console places one, and a person's account or another author can commit one too. A seat, one of the Machine's agents, that finds the file at the start of a run stops. The Orbyt console already uses that path. The Kill Switch page says which work a halt stops and what it misses.
The halt record holds 13 halts, 4 of them global and 9 placed by a console command, from through , both UTC days.
From a console press to the commit: 18 recorded presses, a median of 56.5 seconds, the fastest 43 and the slowest 141. These are the console's times on the path Launch Keys would reuse. They are not Launch Keys latency. The 3 timed global console pauses, the one shape the Launch Keys App would be allowed to dispatch, took 48, 48 and 63 seconds.
Designed
Launch Keys would not write the file. It would dispatch the same halt workflow through a GitHub App of its own, the way the console does, and it would never resume the Machine. In the apps the Kill Switch would sit on a tab called Halt, and its one action is Stop. By default one person's Stop would need no second approver, and an organization could require more people. Resume would need the owner.
The founder's current way to stop the Machine would stay as the fallback until Launch Keys has proven itself.
Measured
The App does not exist yet, but the Machine's code already bounds its login, orbyt-launch-keys[bot]. The halt workflow admits that login for a global pause only, and never for a resume. In the principal record's words:
- the workflow admits its login beside the executor's, and hands github.triggering_actor to the program
- a record naming the App may only be a global pause by the owner
- a run whose triggering actor is not the bot of its record's app is refused before the tree is read
One limit stays. The App's permission on GitHub would be, in the halt workflow's own words, “actions: write, which cannot be scoped to this one file”, so the custody of its key is the control for the repository's other workflows.
The halts and press times are in the halt timeline, and a reader can recount each there: the halts are its rows, the global halts the rows scoped global, the console halts the rows placed by a console command, and the press times both press columns together. The bounds are the Machine's principal record for the App, which is not public, and the design is the project's decisions recorded , and .
What works today, and what does not?
Not yet
As of , these are not done. The list is checked by hand against the project's status notes and decision record, and its last item is the status rule. The date says when.
- A live Stop against a server.
- The GitHub App the Machine would admit. The founder creates it.
- A signed install of the real app.
- A third-party security review with a penetration test.
- A real approval signed through Launch Keys.
Probed on a device
. On an iPhone, an ML-DSA-87 key was created in the Secure Enclave behind a Face ID gate. It signed, and the signature verified. It was not an approval. No request was shown or decided.
Probed on a device
. On a Mac, one Touch ID authorized both signatures on a statement, P-256 and ML-DSA-87, and both verified. It did not settle a live Stop against a server, or a signed install of the real app.
From the project's dated device notes, not reproduced for this page. Neither probe settles the fresh check for each decision.
Measured
Counted
| Language | Source lines | Tests counted | Designed role |
|---|---|---|---|
| Rust | 73,540 | 2,608 | The security core and the server |
| Swift | 22,437 | 1,319 | The Apple apps |
| TypeScript and JavaScript | 6,832 | 646 | The dashboard and the SDK |
| Python | 283 | 52 | A test oracle |
Counted in its own folder and never run here. Lines are its tracked Rust, Swift, TypeScript, JavaScript and Python files, with tests left out. Tests are each language's own test markers in the source, so the count is a floor. A count says how many tests exist, not that they pass. The folder it counts is not public, so these counts are not in figures.json. The same counts appear on Building in Public.
“before we have a third party company using it we have an independent security review”
That review has not happened.
What security and privacy is being built into Launch Keys?
This is the security and privacy design Launch Keys is being built toward. It is a design being built. Details will change, and when they do, the page will say what changed. Each line carries one label, and no label is higher than the project's own code, tests and decision record support.
- Built in development
- Built and tested in development. Not in production.
- Decided
- Settled in the project's decision record. Not built, or built only in part, and the line says which.
- Planned
- On the project's plan, and not yet settled in its decision record.
- Our recommendation
- What Orbyt Labs thinks should come next. Not decided.
The cryptography
Each decision is designed to be signed on the device, twice, and checked on the server. These are the parts, and what each one uses.
- Built in development. A P-256 signing key made in the Secure Enclave of the device. By Apple's design the key cannot leave the enclave. That is Apple's property, not a Launch Keys test.
- Built in development. An ML-DSA-87 key, the post-quantum algorithm specified in FIPS 204, made in the Secure Enclave beside it, on the devices where confirmed: one M1 MacBook Air and one iPhone 17 Pro Max.
- Built in development. Both signatures on each signed statement. The server accepts it only if both verify. Seen in tests and device probes. No real decision has been signed yet.
- Built in development. The keys are made to refuse to sign without Face ID or Touch ID. Seen in device probes. A fresh check for each decision, with a prompt that names it, is not yet verified on a device.
- Built in development. SHA-384 for each device decision and each signed statement. SHA-256 for the audit chain, its Merkle tree and the request body digests.
- Built in development. Canonical CBOR, a strict subset of RFC 8949, so a request has exactly one encoding. A separate domain tag for each purpose, so a signature for one thing never counts for another.
- Built in development. HTTP Message Signatures (RFC 9421) with body digests (RFC 9530) on agent requests, in one strict profile. Agents sign with Ed25519 or P-256, which are not post-quantum.
- Built in development. TLS 1.3 only on the server and the worker, and database connections that check the certificate and the host name. On a local stack on one Mac. The hosted setup is still open.
- Built in development. The Mac app's network code trusts one pinned server certificate, not the system's trust store. Tested in code, and not yet run in a signed app against the server.
- Built in development. Server cryptography on the AWS-LC FIPS module in FIPS mode, checked at each start, and a Linux server build without it refuses to start. The version in use has no NIST certificate. A Mac development run and the Apple apps do not use it.
- Built in development. The project's local merge gate refuses a Rust crate from its ban list of other TLS and crypto libraries.
- Decided. Request content encrypted with a managed data key before it reaches the database, bound to the organization and the request. Today requests are stored unencrypted at the application layer.
- Decided. Server signing keys held in managed key storage. Today they sit in a local key file that only the service user can read.
- Built in development. An encrypted backup of the keys and secrets folder, rehearsed once on a test folder. It does not cover the database, and its encryption is not authenticated.
- Decided. Encrypted backups of the database. Not built yet.
- Planned. Passkeys to pair a new device, and a check that the app is the genuine one on real Apple hardware.
- Planned. Public timestamps of the audit history, and exports that verify offline.
- Our recommendation. A hybrid post-quantum key exchange in TLS, once the cryptographic module supports it.
- Our recommendation. Envelope encryption with AES-256 in an authenticated mode, one data key per organization, and keys an organization manages itself, so it can revoke access to its stored requests.
What the design protects
Each line is a rule the design sets for a request, a Stop or the record. The label says how far it has come.
- Built in development. A person approves what the screen shows. The signature covers the request, the device and the decision, and hidden or look-alike characters show as visible markers. In tests and on sample screens.
- Built in development. A Stop is signed and recorded, in the project's test rig, against a stand-in for GitHub.
- Decided. A Stop reaches the Machine through a GitHub App of its own, with a token for each call. The App would hold Actions read and write and Contents read, and Actions write also lets it cancel, rerun and delete runs and their logs. The Machine admits it for a global pause only. The App does not exist, and no live Stop has run.
- Decided. Resuming Launch Keys is a signed act with its own Touch ID. Restarting the Machine is a separate owner action in the Orbyt console, and Launch Keys never does it.
- Built in development. An audit history chained by hash, with signed tree heads, that the database's app roles cannot edit or delete. Tested on a local Postgres. A database superuser can still skip those rules.
- Decided. A rewrite caught even when someone controls the whole database. That needs devices that keep a signed tree head, which the apps do not do yet, and the public timestamps, which are Planned.
- Decided. People and access change only by a signed statement, and nobody raises their own access. The rules are built in the library and the database, and no route uses them yet. The web dashboard holds no signing key that gives power.
- Built in development. One person counts once, a required approver cannot be swapped for another, an approval after its deadline does not count, and a policy that cannot decide denies. On a test server, with property tests.
- Built in development. Row level security keeps each organization's data apart, with least privilege database roles. Tested on a local Postgres, and the database owner can lift it.
Where it should go
None of these is built. Most are recommendations, and a recommendation is not a promise.
- Decided. No outside company uses Launch Keys before an outside security review with a penetration test.
- Our recommendation. That review repeated each year, with the fixes published.
- Decided. Rate limits, abuse detection and alerts on the server's routes. No rate limiter exists yet.
- Planned. Recovery plans rehearsed on a schedule: a lost device, a lost key, a compromised signer, a database restore. One backup rehearsal has run.
- Planned. A software bill of materials and signed releases, before launch.
- Our recommendation. Server keys in a hardware security module, with a rotation schedule and a written key ceremony.
- Our recommendation. Outside witnesses that countersign the audit log, so no one can be shown two histories, and a public record of each device key registered.
- Our recommendation. Reproducible builds, a second person reviewing each production change, and no standing production access. Today the project has one owner, a local gate and AI reviews.
- Our recommendation. Formal verification of the approval rules, beyond today's property tests, fuzzing and mutation tests.
- Our recommendation. A public security contact, a disclosure policy and a bug bounty.
- Our recommendation. Audit export to an organization's own monitoring, and outside security certifications once Launch Keys is in service.
Privacy
The dashboard is the one web surface. Today it shows sample data and makes no network call.
- Decided. Launch Keys adds no password of its own. After the usual Orbyt sign-in, the dashboard asks for a short code approved on the person's own device, and the Orbyt sign-in alone reads no organization data. The code's format is built, and no sign-in runs yet.
- Decided. A browser session lasts at most one hour, uses a browser key that cannot be exported, and ends when the approving person or device is removed. It is a software key, so malware in that browser could use it for the hour.
- Decided. Emails masked on screens that do not need them. In the contract and the sample data only.
- Built in development. A strict content security policy on the dashboard, tested in a local production build: a test fails if the page calls any origin but its own.
- Planned. The dashboard talking only to the organization's own Launch Keys server.
- Decided. Names and emails kept apart from the signed record, so they can be erased without breaking the audit trail. Built and tested in the database, and no route or tool calls it yet. A deleted person's display name stays in the history, by decision.
- Decided. A written retention schedule for each kind of data.
- Our recommendation. Data residency choices.
Three things Orbyt Labs will not claim
- Requests are not end to end encrypted. The server reads each request to apply the policy. The current build stores it unencrypted at the application layer, and encryption at rest is Decided, not built.
- There is no post-quantum encryption of data. The post-quantum part is the signatures, on the devices where confirmed. A post-quantum key exchange is only a recommendation.
- No outside security review is claimed until one is done. The two internal reviews were by AI reviewers of the model family that wrote it.
Each line was checked against the project's code, tests and decision record as they stood on . Those records are not public, so nothing in this section is in figures.json.
What would prove these claims wrong?
Each claim names its kind. Measured is read from a record. Judged is a ruling someone made and wrote down. Set by hand is a word a person changes when the evidence arrives.
| Claim | Kind | Source | What would disprove it |
|---|---|---|---|
| No real approval has been signed through Launch Keys. | Set by hand | The status, In Development, read from the homepage's rule, and the project's notes checked . | A real approval signed through Launch Keys and recorded. The status then changes, and this row with it. |
| The halt record holds 13 halts, 4 of them global. | Measured | The halt timeline, through . | A count of its rows, or of the rows scoped global, that differs. |
| A signature proves verified key use, not personal presence. | Judged | D-0030, . | A valid signature made without the key, or a record that the key cannot sign with no one there. Until then the Touch ID key, pinned , makes presence an inference, never a proof. |
| Founder-key liveness reads true. | Measured | The daily check's state record, read , republished in the daily pulse. | A read of the same record that says otherwise. |
If the check cannot look, this page says NOT OBSERVED.
Where are the records?
The public files let a reader recount each figure in figures.json. The project's decisions, its device notes, the code count's folder and the key record are not public. Their dated statements are written into this page, each with its limit beside it.
- figures.json: each figure on this page a reader can recount from a public file, how to recount it, and what it leaves out and why.
- pulse.json: founder-key liveness as true or false, and the day the ladder read it.
- halt-timeline.json: the halts, their scopes and dates, and the console's press times.
- decision-ledger.json: the dated rulings on what a signature proves.
Launch Keys questions? Answers.
Follow the build on Substack. (opens in a new tab) Research notes from the Machine.