Security model

A model you can verify, not just trust.

Security shouldn't be a promise on a marketing page. lazyit is built so the guarantees that matter are structural — provable in the code you run on your own servers, not assurances you have to take on faith. Here's how it holds up.

The server can't decrypt your secrets. By design.

Your Secret Manager vaults are end-to-end encrypted. Values are encrypted in your browser before they ever reach the server, and decrypted only there, by a member of the vault. lazyit stores a form it cannot read — not the server, not an administrator, not a database backup can reveal a secret value.

There is no master key on the server, so there is no back door. That's exactly what makes the guarantee worth trusting: you don't have to take our word for it.

Visible to lazyit

Vault names · member lists · secret labels & handles

Never readable by lazyit

Secret values · your password · your recovery key

Names and members stay visible so the app can show a list and admins can manage access — so name vaults and secrets plainly, and never put a secret value in a label.

Scope, plainly: zero-knowledge covers Secret Manager values. Credentials lazyit itself has to use — the SMTP password, the directory bind password, the AI provider's key — are encrypted at rest on the server instead, because the server has to use them.

Vault / production

Production secrets

12 items · 4 members

Encrypted client-side
  • DATABASE_URL••••••••updated 2d ago
  • STRIPE_SECRET_KEY••••••••updated 5w ago
  • S3_BACKUP_SECRET••••••••rotated 14h ago
GitHubRotates every 30s

The server can never decrypt these values.

Layered access, enforced on the server.

No single control carries the weight. Identity, authorization and decryption are separate concerns, each enforced independently.

  • Per-vault membership

    Reaching the Secret Manager and decrypting a vault are two different things. Permission to enter lets you see that vaults exist; only membership of a vault lets you decrypt it. You can't share a vault you aren't a member of — access only ever flows down from people who already hold it.

  • Per-domain authorization

    What you can do is read from lazyit's own database — three fixed roles and the permissions behind them — never from your sign-in token. A misconfigured or tampered token can't grant power inside lazyit. New users start read-only; least privilege is the default. A delegated admin can't hand out more than their own role.

  • Built-in accounts, or your own IdP

    By default lazyit runs its own sign-in and keeps each password only as an argon2id hash — slow, salted, one-way; nobody reads it back, an admin included. Already run Entra ID, Okta or Keycloak? Choose it when you install; it's a once-per-instance choice. lazyit then holds no sign-in passwords at all, and never writes back to your IdP. Built-in accounts are password-only today; if you need MFA, bring the IdP.

The AI gets your permissions. Nothing else.

AI is off until an administrator switches it on, and it never widens anyone's rights. The in-app assistant, MCP clients and headless runs all act as a person or a service account, and lazyit checks every call exactly like a click.

  • Same checks as a click

    Every tool call goes through the same API guards, as the signed-in person. Viewers have no AI access by default.

  • A card for every change

    In the chat, each write waits on a before → after card that lazyit builds from the exact change that will run, not from what the model wrote. Auto-approving routine edits is a per-chat opt-in, off in every new chat, and it never approves a card already waiting.

  • Your password, again

    Giving access or privileges, changing a role or identity, sending someone a way to sign in, and any change to a critical application ask for your password before Approve works. Over MCP and the headless API, changes to critical applications are refused outright.

  • Other people's text is marked untrusted

    An article, a note, a name: anything someone else wrote is marked as untrusted before the model sees it. A change proposed after reading it is flagged and never auto-approved.

  • An AI log nobody edits

    Every change the assistant proposed, who decided and what ran lands in an append-only log; a database trigger rejects edits. It outlives the chat.

  • Transcripts expire

    Chats are deleted after 90 days by default, and only their owner can read them, not even an admin. It's the one hard delete in lazyit; the action log stays.

  • Off by default

    Nothing about AI is active on a new or upgraded instance. The assistant, MCP, web search and document extraction each have their own switch.

  • Out of reach

    Secret Manager values, cleartext credentials like a new token or a temporary password, and the AI's own configuration are never exposed to it.

Read how the assistant is fenced in →

What leaves your server, honestly.

Nothing, until you switch something on. Here is every way out, and what it takes to open it.

Telemetry
None.
Update check
Off by default. When on, a weekly read of GitHub's release list; no beacon.
AI chat & headless API
Prompts and tool results — any record the person asking can read — go to the one provider you configured, and nowhere else. That provider can be a model on your LAN.
MCP
lazyit runs no model. What your client reads goes to whatever model that client uses, under that person's terms.
Web search
Off by default. When on, the provider runs the searches on its side and may pass the queries to its search partner; lazyit itself fetches no page.
Document extraction
Off by default. When on, the whole file goes to your cloud provider, never to a self-hosted model, and no other lazyit data goes with it.
Integrations you set up
Outbound email, access-automation API and webhook steps, the backup's off-site hook, your IdP and directory: each goes only where you point it.
Never sent
Secret Manager values, sign-in passwords, service-account tokens, the provider's API key.

What a provider does with what it receives — retention, training, region — is set by your contract with it. lazyit can't enforce that, so read the notice before you switch it on.

Nothing is hard-deleted. The trail stays intact.

Ownership is a dated relation, never a column — assign and reassign, and the history writes itself. Retire an asset, offboard a person, revoke an access: the record stays. So the system always answers the question that matters in an incident or an audit — who had this, and when.

  • Soft delete — domain data is retired, never erased
  • Append-only logs and ledgers, immutable by construction
  • Full history on every asset, person, grant and revoke

Yours to run, audit and keep.

lazyit is AGPL-3.0, so every claim on this page is one you can read for yourself. It runs entirely on your infrastructure, and nothing leaves it unless you switch it on.

AGPL-3.0

Read the source, fork it, run it forever. No black box.

Self-hosted

Your servers, your database, your backups. Nothing leaves unless you switch it on — AI included.

No telemetry

No tracking, no per-seat billing. The weekly update check is off until you turn it on.

Found something? Tell us privately.

If you believe you've found a vulnerability, please report it privately first, so it can be fixed before it's public. The fastest path is a GitHub Security Advisory — it opens a private channel with the maintainer.

Being straight with you: lazyit hasn't had a third-party security audit yet. So rather than point to someone else's stamp, we keep the code open and the model simple enough to audit yourself.

What it has had: in October 2026, an internal audit of the whole backend logged 105 findings — 1 High, 10 Medium, 94 Low, no Critical. 104 are fixed; one is accepted as a known risk, flagged at boot. Four older Low findings remain open, tracked in the open in the repository.