Sovereign compute in one binary and one database.
A self-hostable app and agent platform you can move by copying one file. Apps, storage, auth, realtime, AI, and agents — without a service zoo. The binary is replaceable. The database is the instance.
One product, spread thin across a service zoo.
Modern app development often splits one product across many rented surfaces — hosting, auth, database, object store, realtime, queue, serverless, email, AI, dashboards. The cost is not just bills. State and authority drift apart. Agents become a privileged integration mess.
$ ls ~/.config/holm/ data.db holm # one binary + one database = a complete node
The whole platform, in twelve nodes.
Holm compresses a service zoo into one runtime. Pick a scenario, hover a node, or click in to read what it does, the binding you'd reach for, and where it sits in the system. Every node lives in the same SQLite file.
The database is the instance.
An app is a directory.
Drop a folder, run one command. Static, BFBB, or Vite — the same source can
run raw, or compile through a bundler. ESM in api/main.js. Relative imports
inside api/. Top-level await. Bindings injected at runtime.
The shape
my-app/ ├── manifest.json # name, title, visibility ├── index.html # web surface ├── api/ │ └── main.js # ESM handler for /api/* └── private/ ├── secrets.json # auth-gated └── agents/ └── parvathy/ ├── agent.json └── AGENTS.md
The deploy
# local node holm @local app deploy ./my-app # named remote peer holm @prod app deploy ./my-app # own a hostname end-to-end holm app deploy ./my-app \ --host app.example.com
The handler
// api/main.js export default async function handler(req) { if (req.path === '/api/notes') { const notes = await holm.app.member.ds .find('notes', { limit: 50 }) return json(notes) } return json({ ok: true }) }
BFBB — build-free, but buildable
# no build step holm app deploy ./blog # or, with Vite cd ./blog && pnpm build && \ holm app deploy ./blog/dist
Agents are members.
Not bots bolted onto a PaaS. A native agent uses the same identity model, the same storage, the same auth, the same approvals as a human. It lives inside the app's trust boundary — explicit tools, durable memory, server-authoritative writes.
agent.json
{
"name": "Parvathy Menon",
"role": "app_admin",
"triggers": ["message", "webhook", "event"],
"tools": [
"holm.ai.chat",
"holm.app.member.ds",
"holm.app.kv",
"holm.email.send",
"holm.approvals.request"
]
}
-
messagesomeone DM'd the agent on a channel
-
heartbeata recurring schedule fired
-
webhookan external service called in
-
eventan in-app event was emitted
What one node can carry.
Benchmarked on a $6 VPS — not a marketing rig. Holm uses SQLite's single-writer shape intentionally; writes serialize through a queue. Predictable ceilings beat fake infinite cloud fabric. When one node isn't enough, add another and route by app.
Holm is not for huge multi-region workloads today. It is more than enough for many personal, internal-tool, small-SaaS, community, and agent-backed apps — on hardware that costs less than a coffee subscription.
Boring is a feature.
Four commands you run for years. Install. Deploy. Backup. Upgrade. That's the operational surface. The database is one file. The binary is one file. Restore is a file copy.
One binary
One directory
One file copy
One swap
Pre-1.0, fast-moving, and honest about it.
Holm is source-available today.
Free for all except entities above $1M annual revenue.
Each release moves to fully open source (MIT) after the deferred window.
Releases ship from holmhq/releases; issues live at holmhq/issues.
License posture
Hosting is renting.
Holm is owning.