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.
Production secrets
12 items · 4 members
- DATABASE_URL••••••••
- STRIPE_SECRET_KEY••••••••
- S3_BACKUP_SECRET••••••••
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.
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.