Security & Data Flow

Designed to SOC 2 trust principles.

Your source code never leaves the machine in readable form.

Last reviewed: April 2026

Data flow at a glance

Encrypted diffs if you're using an IDE, and project meta-data if you're using Claude Code.

Client-side encryption boundary (zero-knowledge) · TLS in transit

What crosses the wire

Every category of data, audited.

Data Encrypted client-side? Stored where
Source code, diffs Zero-knowledge ✓ AES-256-GCM Google Cloud Storage
encrypted blob
Intent code blocks Zero-knowledge
snippet, code content		 ✓ AES-256-GCM MongoDB Atlas
encrypted field
Intent & decision management information
titles, descriptions, scope, constraints, rationale		 — TLS in transit MongoDB Atlas
Account info
email, profile, billing metadata		 — TLS in transit MongoDB Atlas
Payment details — TLS in transit Stripe
we never see card numbers
LLM calls (Translation add-on) — TLS in transit Not retained after response
never seen if you BYOK
Local cache
~/.kawa-code/.storage.caw		 ✓ locally generated key Your machine only

What is never stored, anywhere on our servers

  • Your raw working-tree files
  • Source code or diffs in readable form
  • Your encryption keys
  • LLM prompts when you bring your own API key
  • Credit card numbers (handled by Stripe)
  • Repository contents — Kawa Code never clones your repo

What data we work with

Intent and decision management information — titles, descriptions, scope, constraints, rationale — is shared with your team via our secure API.

What our API enables for your team:

  • Cross-repo decision search would be impossible if every query had to re-derive a per-repo key.
  • Conflict detection across teammates needs the API to compare scopes.
  • Decision evolution (supersedes / contradicts / specializes) runs server-side on metadata only.

For teams that need every byte to stay on their own infrastructure, the entire ecosystem can be installed on-premise, fully air-gapped.

Threat model

What we protect against, and what we don't.

Protected against

  • A compromised Kawa API server — encrypted blobs are unreadable without keys that never reach the server.
  • A compromised storage backend — same.
  • A malicious or curious Kawa employee — we cannot decrypt your code.
  • Network interception — TLS 1.2+ on every connection.

Not protected against

  • A compromised developer machine — if your machine is owned, your working tree is exposed regardless of us.
  • A malicious editor extension running alongside ours.
  • Legal process for intent and decision management information — we comply with valid legal process for the records we hold.

Cryptography — for the engineers

Specifics of the client-side encryption boundary.

Cipher

AES-256-GCM

Authenticated encryption with a 128-bit auth tag.

Key derivation

PBKDF2-HMAC-SHA256

600,000 iterations, 32-byte output.

IV / Nonce

12 random bytes per message

Generated fresh from the OS CSPRNG on each encryption.

In transit

TLS 1.2+

All API and storage connections.

Local cache

Locally generated key

Encrypts ~/.kawa-code/.storage.caw at rest. Stays on your machine.

On-premise & air-gapped

The entire ecosystem can be installed inside your own network — for complete security.

Infrastructure & compliance

Hosting

Google Cloud Platform, dual-region in the United States. Cloudflare for DNS and edge.

Database

MongoDB Atlas, hosted in a private VPC with no public internet exposure. Encryption at rest, automated backups, and IP allowlisting on the operator path. Intent code blocks are encrypted client-side before they ever reach the database — even with full DB access, our team cannot read them.

Blob storage

Google Cloud Storage. Encrypted blobs only — we cannot decrypt them.

SOC 2

Our internal processes are designed around SOC 2 controls. We have not yet completed a third-party audit; the report is on the roadmap. We will update this page when certification is in hand.

On-premise & air-gapped

For teams that need every byte to stay on-prem, the entire ecosystem installs on your own infrastructure — air-gapped if you need it — and the hosted API is removed entirely.

Security FAQ

No. The encryption keys for diffs and code blocks are derived on your machine from inputs we never receive. Even with full database and storage access, our team cannot reconstruct your code.

Yes — and it's the same exposure as any AI coding assistant. When AI conflict resolution runs, your changes plus the overlapping peer changes (reconstructed locally on your machine from the encrypted peer diffs) are sent to the model provider — Anthropic by default — so it can judge and merge them. This does not weaken our zero-knowledge guarantee: the Kawa Code server still never holds your key and never sees code. Teams that require code to never leave the machine can run the resolver against a local model via Ollama.

No. The desktop app reads your local working tree only. Our GitHub App holds Metadata: read-only, which cannot read repository contents, and the server never clones anything.

All hosted infrastructure is in the United States.
EU and Japan data residency is on the roadmap; reach out if you need it sooner.

Yes. Deleting your account purges your account record, intent and decision management information, and the encrypted blobs associated with your repositories. See the Privacy Policy for retention details.

Responsible disclosure

Found something? We want to know.

Email mark@kawacode.ai

security.txt (RFC 9116)