Procurement asks three things: where the data lives, who could reach it, and whether you can prove what happened. Most teams answer them with a project, months after the product shipped. Here each one is a read against your own Cloudflare account, because the kit was built around those questions rather than retrofitted to them.
How it usually goes
The product works. A large customer sends a security questionnaire, and the answers turn out to live nowhere. You have probably seen the pattern, because almost every team builds the same four things the same way.
Events go to a log store as text. Asking who changed a role last March takes a regex and a week.
Here, every security-relevant act is a typed row in your own D1, and the questions an auditor asks are routes that answer in one SQL statement.
Somebody exports the admin list each quarter and asks managers to tick boxes. Nobody can say which grants were ever used.
Here, every membership, connection and key change keeps its before and after, and every connection's scopes are counted as used or refused.
A person asks to be forgotten, and an engineer writes a script that finds them in the tables somebody remembers.
Here, every capability that holds a person's rows exports them and erases them, or says why it keeps them. A capability that skips this fails the kit's build.
The admin tool is somebody's SaaS, holding a copy of your customers' data, and it lands on your risk register as a processor.
Here, nothing Pithy operates sits in a request path. The dashboard and any agent you connect are clients you can revoke, and neither holds data of yours.
None of this is an add-on you buy later. It is how the kit is built, so the compliance answer is a read, not a project.
In practice
Every capability runs in your Worker, in your Cloudflare account, against your D1. There is no Pithy-operated service in any request path, so there is no vendor to add to a risk register as a processor of your customers' data.
The dashboard, and any agent you point at your Worker, come in through the control plane as clients rather than hosts. Each holds its own scoped credential: a key whose public half you hold, or for a CI job, a trust in the job's own identity, with no key at either end. Every call lands in your own audit trail under that client's actor kind, dashboard, agent or script, so what a tool did is answerable separately from what your users did. Revocation is a row you change, and it needs nothing from us.
Your users' own agents never touch the control plane. If you compose the MCP capability, they come in as your users: through your routes, with that user's role, after that user approved them, and recorded as that user acting through an agent.
If your team builds with Claude Code, the agent team holds the same line. It never deploys without a yes, a yes covers one environment, production takes a typed phrase, and it never runs pithy remove or a rollback. A kit gap it reports goes to GitHub only on your yes, written from scratch, never with your code or a secret.
Pithy holds no certification on your behalf, and this page claims none. What it gives an assessment is evidence: records in your own account that you can read, about a system you run.
The questions an auditor asks
These are routes on your own Worker, behind the control plane's credentials. They are denied by default, each scope covers one operation, matching is exact, and a staging credential cannot reach production. Every call, allowed or refused, lands in your audit trail.
Every membership, connection and key change is in your trail with its before and after: a member's role, a connection's scopes, a key registered, expired or revoked. One read returns every change in a window, oldest first, with who made it and which kind of client they were. Who held what on a given day is those changes replayed from a known state, and nobody reads events one at a time to get there.
Your own operators count too. An administrator added by hand, the founder of an account, and ownership changing hands are all role changes, and they read as role changes.
Before an organization is suspended or deleted, a preview names every member whose own account it would reach, and why each one it skips is skipped. It runs the same function the act runs, validates the same way, and writes nothing. A preview the act would refuse is refused too.
What it does not do. It hands you changes, not a snapshot. A change made before the trail kept its before and after reads as changed, detail not recorded, never as a guess. Deleting or suspending a whole account reads as that one act, not as a change per member. And a preview is a snapshot: a member added between it and the act changes what the act does, and the act's own response is the record.
For one credential, or one of its keys, over a window: a row per tenant, route and outcome, with how many calls, how many distinct subjects, and the first and last of them. Expand a route and it answers the subject ids it touched. That list decides who gets a breach notice, and building it is usually the most expensive hour of an incident.
The tenant comes from what the handler itself recorded in the same request, never from a guess about the path. The answer carries no IP address, no user agent and no other detail from the events.
What it does not do. A call whose handler named no tenant, or that has no Cloudflare request id to join on, reached no named tenant, and the read says so rather than inventing one. A path that matches no declared route is its own row, marked unmatched. It answers from what your trail holds, and no further back.
For each connection, the scopes it used and the scopes it was refused, per key, with when each last happened. A grant nobody has exercised all quarter is one you can see and take back. Refusals sit beside use, so an under-grant shows as clearly as an over-grant.
A credential that verified and then asked for a scope it does not hold is named on the refusal: its connection, its key, the scope it wanted. That is what probing looks like, and it is attributed. The answer also gives the oldest event the trail holds, so you know how far back it actually reaches.
What it does not do. A call that failed verification names nobody, because nothing about it was proven. Under a key, only a token's first presentation is attributed: a signature proves who minted a token, not who presented it, so a captured token replayed at other routes is refused each time and names nobody after the first. Under a CI trust the job's own token is checked on every call, so a captured one is accepted at that one environment until it expires, minutes later, and each of those calls is attributed to the trust, not to whoever held the token.
Every kit capability that holds rows about a person answers for them. An export is one document with an entry per capability, saying what it holds and what a purge will do with it. It carries no credential: no session token, no provider token, no secret. Taking one is itself audited, with the reason and which parts answered, never the data.
A purge runs as a Cloudflare Workflow, one step per capability, so a step that fails retries alone and the steps that finished do not run again. Most capabilities erase. Multiplayer anonymizes, because a match result is every player's. Four keep their rows, and the export says why in a sentence written for the person: payments for tax and accounting records, email suppressions so your unsubscribe holds, the audit trail as the record of who did what, and the control plane's legal holds as the record that a hold stood. A kept step is recorded as kept, never as erased.
And it stays true. A capability whose tables name a person, and that declares no export, fails the kit's build.
Then prove it. One read attests a person's or an organization's erasure from the purge's own record: when it was deleted, by which kind of actor and why, each step erased or kept with its reason, whether the purge completed, and the audit event behind each step, by id and its place in the trail's hash chain. Another counts every purge in a period and names each one that failed or is overdue, with the step it stopped at. Nothing about the person is in it but the id.
How long everything is kept is one block in the Worker's config, reviewed and deployed like code: each purge window, how long the audit trail is kept by action, and how long an account may sit inactive while it holds personal data before it is deleted the same way any account is. The kit keeps the record of who managed the Worker for at least a year, whatever the block says. And when counsel asks you to stop deleting, a legal hold on a person, an organization or a tenant's audit trail stops every purge, prune and inactivity deletion touching it until it is released. A hold can only preserve, and placing and releasing one are both audited. On Enterprise, the dashboard's evidence pane shows the policy and every hold, places and releases one with a reason, and draws a period's purges and each one's attestation.
What it does not do. No export for an organization as the subject. The attestation signs nothing: it cites the audit trail, and the trail's chain is what makes it tamper-evident. The purge runs once the deletion window closes, 30 days unless you set it, and only in a Worker that binds its two Workflows; until then a deletion shuts the account and erases nothing. The retention bases are the kit's, written for the common case. Whether they hold where you operate is yours to decide.
The ones a reviewer asks about do. Every sign-in link and code auth issues is recorded as issued, used or expired, with the mail job that carried it, so sign-ins that failed because the mail never landed is a count. The record never holds the token or the address.
Every payment notification a store sent reads as projected, pending or abandoned, with the purchases and subscriptions it changed, and the provider's payload is never in the answer. Every git token the kit mints records who it was minted for, so who can still push here has an answer, and one token, or every token on a repository, is revoked with a required reason.
And the trail itself is append-only. No route deletes, edits or prunes an audit row, because a credential that could erase one could erase the evidence of its own use. The one way an event leaves is the retention prune your own Worker runs on the windows its config declares, and it leaves a tombstone the verify reads across. Somebody who edits the database directly is caught too: each tenant's events are a hash chain, checkpointed hourly to an R2 bucket under object lock, and an export verifies offline with pithy audit verify, trusting neither your Worker nor us.
What it does not do. A git token minted outside the kit, in Cloudflare's dashboard or a script, is listed with no holder, because nothing recorded one. A notification that finished before the Worker recorded what it changed reads with its changes unknown. The chain shows that a row was changed; it does not stop the change, and events written before it began are marked, not chained. And audit is a seam: with no audit capability composed, nothing is recorded.
One read returns it, from the deployed Worker. For seven controls, audit logging, how every route verifies its caller, who holds management access and for what, key and secret rotation, change history per environment, data classification and encryption at rest, and CSRF wherever a cookie is accepted, it reports the facts it read, the declaration each came from, and the SOC 2 and ISO/IEC 27001:2022 references the control answers. Each control says evidenced, gap with what is missing, or not derivable with why.
Nothing is kept by hand. The pack reads what the Worker composes and records, so it cannot drift from the code, and the table it follows is versioned and named on every pack, so last quarter's and today's can be told apart.
What it does not do. It never says compliant, and never says a control was met: an auditor decides that. It reaches no further than the connection may, so a connection without the migrations or secrets read gets not derivable for those facts, never the facts. It proves controls present and changes nothing. No CLI command reads it. On Enterprise, the dashboard's evidence pane draws it and exports it as JSON, as your Worker answered.
Your Worker derives it, the record GDPR Article 30 asks a controller to keep. Each kit capability that stores personal data declares what it does with it: the purpose, the data classes, a default legal basis, and who receives the data. You add your own activities, and replace a basis the kit stated, in one block of the Worker's config, reviewed and deployed like code. One read assembles them with how long each class is kept, the evidence pack's controls that protect the data, and, for consent-based processing, how many people hold a grant that stands today.
The gaps are named, not filled in. An activity with no legal basis, a consent basis with no purpose behind it, a class an activity claims and nothing stores, a class something stores and no activity claims, health data no consent purpose covers, and a purpose with no grant standing now each come back as a gap.
What it does not do. It decides no law: which basis holds where you operate is yours and your counsel's. It reads the privacy markers on your schemas, so a field nobody marked is one it cannot cross-check. It changes nothing it describes. No CLI command reads it. On Enterprise, the dashboard's evidence pane draws it, every gap named, and exports it as JSON.
Two kinds of agent reach a Pithy app, and the trail keeps them apart. One you connect to administer the system, with pithy mcp connect: it holds its own connection, records the signed-in person who authorized it and what it is for, and every call it makes is a control-plane row marked agent. The other is a user's own, approved by that user on a consent screen: each tool call is a row naming the user, the session they approved it in and the client, marked agent too. One filter on actor kind finds both.
Every admin scope says what kind of thing it lets a caller do: read, write, send, charge, delete, or touch credentials. So a review can ask which agents can delete anything, not only which scopes they hold.
When someone leaves, pithy dashboard connections --principal <email> lists every key and trust that person authorized, across every environment, and --revoke --reason ends them all, recording each one. An agent one of your users connected is theirs to end: they revoke it from their own connected-applications screen, without asking an administrator, and its next call is refused.
What it does not do. A user-agent row keeps the shape of a tool's arguments, never their values, so it tells you which record was touched and not what was written to it. A token already minted under a revoked CI trust stays usable until it expires, and the command says so. A connection registered before principals were recorded is listed apart and never revoked by a match on an email.
Regulated data
Mark a field pii(), phi(), secret() or pci() in its Zod schema, and that value no longer compiles into a log line, an audit record or an error detail. redact gives you the masked view instead. Nothing at runtime changes, and no column is added.
Your control plane reports which schemas and fields hold which class, derived from the code that is running rather than from a spreadsheet someone keeps. Unmarking a field is a diff a reviewer sees. pithy privacy enable declares the classes your project holds, closes console, and deploys refuse to ship with it open. pithy privacy scan suggests what to mark. It never decides for you.
The dashboard's privacy pane reads that inventory on every plan: each table and its fields, with each field's class and whether it rests encrypted, the classes held but never declared, and the ones declared but never marked, exported as CSV or JSON for an audit response. On Enterprise we watch it. Every change is recorded with the build it arrived in, and you are mailed when a field loses its marker. The history keeps field paths and class names, never a value, for thirteen months by default and up to six years.
Mark the same field encrypted() and it rests in D1 as an AES-256-GCM envelope bound to its table, its field and its row, so a ciphertext copied anywhere else does not open. An optional blind index finds a row by exact value or email address. Fields seal under a key of their own, never the master key, and the nightly rotator moves it to a new version every 30 days, re-seals what is left on the old one, and retires it only once nothing needs it.
What it does not do. An encrypted column answers equality through its index and nothing else. No ranges, no sorting, no LIKE. Which rows hold a value, and roughly how long it is, stay visible. The key lives in your Cloudflare account beside the Worker that uses it, so this protects a D1 export, a backup or a leaked read token. It does not protect against a compromised Worker, which can read what it was built to read.
In practice
Say a laptop holding a key to your management connection is stolen. You run pithy dashboard revoke-key --env prod --key-id <id>. It writes to your own D1 and calls nobody, and the next request signed with that key is refused.
Then you ask the trail. Reach, for that key since it was registered, returns a row per tenant and route. Say two tenants, and one route that reads user records. Expand that route and you have the subject ids it touched. Usage for the connection shows whether the key asked for scopes it did not hold. Access history shows who registered it, and when.
By the end of the afternoon you have a named list of whose data was reached, by a credential you have already revoked, from records that sat in your own account the whole time. Nobody exported a log. No vendor had to be asked. That list is what your counsel needs to decide who gets told.
What you would compose
Real git repositories for your own customers, on Cloudflare Artifacts. An owner, a grant per person, and tokens that live fifteen minutes.
pithy add artifacts
A queryable trail of every security-relevant action, attributed to the right actor.
pithy add audit
Passwordless sessions, mobile and web both first-class. Magic link, email OTP, Google, Apple, GitHub, Facebook, Microsoft.
pithy add auth
Consent recorded the way a regulator asks to see it, from a checkbox to a signed authorization. Email's marketing mail and tracking follow it.
pithy add consent
Let a management client reach into your own Worker, with no data plane in between.
pithy add controlplane
Every send is a durable job: scheduled, retried, tracked. No mail ever sent inline.
pithy add email
Language for your app — negotiated per request, rendered through one seam. No tables, no bindings, no error codes of its own.
pithy add i18n
An analytical tier for event and telemetry data — one schema object derives the ingest stream, the table and the query types.
Your users connect Claude or ChatGPT to your app. Each agent acts as the person who approved it, through your own routes, with that person's role.
pithy add mcp --floor power:agents:use
Accounts, the people in them, and the roles you declare — with invitations bound to an address and ownership that moves only when somebody accepts it.
pithy add organization
One encrypted store per environment, a worker-only master key, and automatic at-rest rotation.
pithy add secrets
General file storage in your own R2 bucket, with an owner, a quota, and a link you can take back.
pithy add storage
An inbox that lands mail in your own D1, classifies it on your own AI, and knows who sent it.
pithy add support
A humanity check that stacks on any route. It answers is this a human, never who is this.
pithy add turnstile
Semantic search over your own content. Workers AI embeds, Vectorize indexes, D1 keeps the text.
pithy add vector
What it costs
The capabilities are free at any scale, on any number of applications — MIT, except audit, which is FSL-1.1-MIT and converts to MIT two years after each release. What the dashboard sells is the admin interface itself — the screen your team administers the application from, and the work of keeping it correct. Reading is free forever, and seats are never charged for, because a team should not pay per head to administer what it already owns.
The infrastructure bill is Cloudflare's, on your own account, at your own negotiated rates.
Cloudflare sets and changes these prices; their pricing page is the authority, not this one. Pithy itself is free and always will be.
Add one capability, deploy it, and see the shape before you commit to the rest.