llms.txt
Compare with other sites' llms.txt files →# Lathe - From your agent to a live product. (Postgres 17, Redis 8, CouchDB 3, NATS 2 and SeaweedFS 4, your choice of data engines, container apps and sign-in on one dedicated machine; paid plans at a flat price)
> Postgres 17, Redis 8, CouchDB 3, NATS 2 and SeaweedFS 4, your own container images and sign-in for them on one dedicated machine, run for you:
> paid-plan tested backups, TLS, a REST API and an MCP server. This document is for AI agents and LLM-based tools. It states what Lathe sells, what
> it costs, what is and is not included, and how an instance is obtained, in plain text with no marketing.
## Pages
- [Lathe: from your agent to a live product](https://lathe.live/): From your agent to a live product. Start Free at $0; paid plans from $15/month with daily backups.
- [Pricing: five plans from Free · Lathe](https://lathe.live/pricing): Free $0; paid plans $15-$89/mo: a dedicated machine, storage, 20 TB and every engine.
- [Ship your product with a coding agent and Lathe MCP · Lathe](https://lathe.live/agents): Connect your coding agent to Lathe, choose a dedicated machine and the engines your product needs, and use the portal, REST API or MCP.
- [Terms of service · Lathe](https://lathe.live/terms): The terms under which Lathe provides dedicated instances: fees, billing, data, availability and termination.
- [Support · Lathe](https://lathe.live/support): How to reach Lathe support, how fast we answer, where to check whether something is down, and what to do about a connected AI assistant.
- [Privacy policy · Lathe](https://lathe.live/privacy): What Lathe keeps about you as an account holder - email, billing details, logs - why, for how long, who else sees it, and how to have it corrected or deleted.
- [Reliability: backups, restore tests and limits · Lathe](https://lathe.live/reliability): Paid plans: daily backups kept 7 days and restore-tested monthly, what happens when something fails, and what Lathe does not do.
- [Host your app on the same machine as its database · Lathe](https://lathe.live/apps): Your container image on the dedicated machine that runs its databases: deployed from a push, served on your domain over TLS, nothing extra. From $15 a month.
- [Sign-in on your own Postgres, no price per user · Lathe](https://lathe.live/sign-in): Email links and codes, OAuth, MFA and sessions for your app, with the users in your own Postgres on a dedicated machine. Nothing per user. From $15 a month.
- [Managed PostgreSQL 17 on a dedicated machine · Lathe](https://lathe.live/postgres): Paid PostgreSQL 17 with PgBouncer, TLS, pgvector and restore-tested daily backups on a dedicated machine you do not run. Flat price from $15 a month.
- [Managed Redis 8 with TLS on a dedicated machine · Lathe](https://lathe.live/redis): Redis 8 with TLS, a password, a memory budget you set and a console in the portal, on the same dedicated machine as your database. Nothing metered.
- [Managed CouchDB 3 on a dedicated machine · Lathe](https://lathe.live/couchdb): CouchDB 3 over HTTPS with admin credentials, Fauxton, replication and Mango queries on your own dedicated machine. Flat monthly price, nothing metered.
- [Managed NATS 2 with JetStream on a dedicated machine · Lathe](https://lathe.live/nats): NATS 2 with JetStream persistent streams, TLS and credentials on the same dedicated machine as your database. Streams managed from the portal. Flat price.
- [S3-compatible object storage on a dedicated machine · Lathe](https://lathe.live/object-storage): Buckets over the S3 API with TLS and keys of your own, on the dedicated machine beside your database. Any S3 SDK, presigned URLs, flat price, nothing metered.
- [Sitemap](https://lathe.live/sitemap.xml): every page above, machine-readable.
## What it is
- Positioning: best value for money for solo builders and small teams - the whole machine a VPS would give you, run by Lathe like a managed platform would, with nothing metered. Not a fit for workloads that need read replicas, failover, or one instance living in more than one place.
- Managed Postgres 17, Redis 8, CouchDB 3, NATS 2 and SeaweedFS 4. Each customer gets a dedicated instance (its own CPU, RAM and local NVMe disk), not a schema in a shared cluster. An instance runs any subset of the engines; each engine has a memory budget out of the plan's RAM (the rest of the plan runs the box itself) that the customer can change.
- Postgres 17 (relational sql database; PostgreSQL): the SQL database, with PgBouncer on 6432; port 5432 direct, 6432 pooled, TLS required. Standard, rock-solid; pgvector and the usual extensions.
- Redis 8 (cache and real-time; AGPL-3.0): cache, queues and sessions; JSON, search and time series built in; port 6379, TLS required. In-memory speed; append-only log for durability.
- CouchDB 3 (nosql document store; Apache-2.0): JSON documents over HTTPS, with replication and Mango queries; port 6984, TLS required. Erlang engine; tiny idle footprint; sync-friendly.
- NATS 2 (messaging and streams; Apache-2.0): pub/sub, request-reply and JetStream persistent streams; port 4222, TLS required. Go single binary; queues and event streams.
- SeaweedFS 4 (s3-compatible object storage; Apache-2.0): buckets for files, uploads and backups over the S3 API; port 8333, TLS required. Any S3 client and SDK; presigned URLs for uploads straight from a browser.
- Apps (your web apps): the apps engine runs container images of the customer's own on the same machine, any language, pulled from their registry (a private one with a pull token). The box passes PORT and every engine's URL with its password into the environment, serves a public app over https on a name of its own (the instance's name with the app's name appended) and on the customer's domains with certificates it obtains itself, and deploys by starting the new container beside the old one and moving traffic once the health path answers; a build that never answers changes nothing. Deploys come from a push. A GitHub repository connected to an app is built by Lathe itself on every push to the branch and deployed when the build is green: no workflow file, no image name and no registry credentials of the customer's, and nothing is written into their repository. A repository with a Dockerfile is built from it, one without from what its files say it is (Node, Python, Go, PHP, Ruby, Java, Rust, static sites). The app's environment is given to the build as well as to the running app. A failed build is not retried on its own and can be built again from the card. A repository whose own workflow builds and pushes an image deploys on a green run of that workflow instead, and any CI can call the deploy endpoint. Rollback is the previous tag. State under /data is kept across deploys. Included in the plan price; no charge for the app, its traffic or its domains. Contract for the image and every field: app_guide over MCP, GET https://app.lathe.live/api/v1/guides/apps.
- Auth (sign-in and users): sign-in for the customer's app, run beside it on the machine: email links and one-time codes, passwords, OAuth (GitHub, Google and about twenty providers), TOTP, passkeys, sessions and refresh tokens, with the users in the auth schema of the instance's own Postgres, readable by the owner role. Built on the open-source Supabase Auth server, so supabase-js and the Supabase auth clients work unchanged (createClient with the URL and the anon key). Needs postgres and apps on the same instance; served under /auth/v1 on a name of its own or on a domain of the customer's. get_connection_urls carries the URL, the anon key, the service key, the JWKS URL and the callback URL. Every setting (site URL, redirects, providers, SMTP, templates, session lengths, rate limits, MFA) through the portal, the API and MCP. Included in the plan price; no price per user.
- On paid plans, storage and outbound traffic are included in a flat monthly price. Nothing is metered: no storage, egress, connection or request charges, and no price per user. Paid plans include 20 TB of outbound traffic a month; above that we contact you first, and there is no automatic overage charge.
- Locations: Finland or Germany, chosen per instance when it is created.
- Operator: Lathe. Support by email, support@lathe.live, replies within 24 hours on business days.
- No refunds except where the law requires.
- Free plan (tier "free"): $0, 100 GB outbound per calendar month, no daily backups. 0.5 vCPU, 1 GB RAM, 10 GB disk and 100 GB of traffic a month, nothing to pay now or later, one per person, and no daily backups. It upgrades to Mini on the same machine, keeping everything on it. No card and no payment page; never charged. Not for organizations.
## Paid plans (USD per month, billed monthly in advance; every paid plan includes 20 TB of outbound traffic a month)
plan vCPU RAM storage price
mini 1 2 GB 20 GB $15
starter 2 4 GB 40 GB $29
plus 4 8 GB 80 GB $49
pro 8 16 GB 160 GB $89
- Mini upgrades to Starter in place: the engines restart once, nothing moves, the address stays.
- Paid-plan first payment: the first month is paid on a hosted card page when the instance is created; the card is kept for the monthly renewals. The free plan has no payment at all. A discount code from an invitation reduces the first payment only. New accounts may run one instance until their first monthly renewal succeeds.
- Cancelling a paid plan: delete the instance from the portal (or API/MCP); billing stops and a final snapshot is kept 7 days. Failed renewals are retried on days 1, 3 and 7, connections are blocked after 7 days, and the instance is deleted after 21 days.
- Plans move up only. Upgrading grows the disk permanently; there is no downgrade.
- More storage means the next plan. There is no storage add-on.
## Shared features; backups and traffic differ by plan
- PostgreSQL 17 with pgvector, pg_stat_statements, pg_trgm and pgcrypto available.
- PgBouncer connection pooling in transaction mode on port 6432; direct Postgres on port 5432.
- Redis: password on the default user, append-only persistence fsynced every second, noeviction. CouchDB: single node, HTTPS with basic auth as admin, every request authenticated. NATS: one user, TLS required, JetStream on local disk.
- Engines are chosen per instance, any subset; at least one is on. An engine switched off is stopped with its data kept on disk and comes back when switched on.
- TLS required on both ports; scram-sha-256 authentication; one database owner role.
- Optional IP allowlist (a per-instance firewall). Default is open to the internet with TLS and scram.
- Paid plans: daily full-disk backups, 7 kept. Any of them can be restored in place from the portal: same address, so connection strings keep working. A snapshot is taken before every restore and kept 7 days, so a restore can itself be undone.
- Paid plans: monthly automated restore verification: a throwaway server is built from the latest backup, pg_amcheck and a row-count sample run against it, then it is destroyed.
- Self-serve actions in the portal, the REST API and MCP: create, restore, reset (wipe and re-initialise), rotate credentials, IP allowlist, resize up, delete (paid plans keep a final snapshot 7 days); per engine: memory budget, on/off, settings, restart, reset; inside the engines: Postgres databases and extensions, a Redis key browser and console, CouchDB databases and Fauxton, NATS JetStream streams.
- Automatic reallocation: memory moves between an instance's engines and apps from what each one holds, inside the plan's budget, at most once a day and with nothing restarted (on by default; a toggle per instance in the portal, `PUT /instances/{id}/reallocation` and `configure_reallocation`; the instance carries the last move and the current advice; a bigger plan is never taken on its own).
- Monitoring on the instance page: CPU, memory, disk, network, per-engine figures (what each holds against its ceiling) and per-engine traffic over 1 h, 24 h and 7 d. Webhooks: every event about an instance posted to the customer's https endpoints, signed, retried.
- Patching: every engine's minor versions and OS security updates in a fixed window, Sundays 03:00 UTC, announced by email beforehand.
- Disk protection: email and portal banner at 80% full; at 95% Postgres stops accepting writes until the plan grows or space is freed; the other engines have no such switch, so on an instance without Postgres the warning is the guard.
## Scope
- Paid-plan backups are daily full-disk images, 7 kept; a restore uses any of them, and the restore point is that image.
- One instance per database; a paid instance is restarted automatically if it stops answering. Read replicas are not offered.
- Fully managed: no shell or SSH, no superuser, no custom postgresql.conf, no untrusted extensions. Reset and restore are the recovery tools.
- Datacenters: Finland or Germany, chosen when the instance is created.
- Sign-up happens in the web portal: sign-in is a magic link sent by email, so an agent that can read a mailbox and drive a browser can open an account itself. Instance management is available three ways with the same rules: the portal, a REST API and an MCP server (below).
## API and MCP (for agents and code)
- Credential: either OAuth (the MCP endpoint's 401 points at its authorization server; dynamic client registration and PKCE, the customer signs in with the email link and approves - this is what Claude.ai custom connectors do), or an API key created on the portal's Access page (https://app.lathe.live/account/access), sent as `Authorization: Bearer lathe_…`. Either acts as the customer and cannot create keys or connect other apps.
- One-paste setup for a coding agent: https://lathe.live/skill.md says how to connect the MCP server from Claude Code, Cursor and other clients and walks the flow from an empty account to a running machine and a deployed app. A person can paste "Read https://lathe.live/skill.md and follow it" into their agent.
- MCP server (Streamable HTTP): https://mcp.lathe.live - tools: list_plans, get_account, update_account, get_billing, list_instances, get_instance, get_connection_urls, refresh_access, revoke_access, list_access, create_instance, update_instance, configure_engines, configure_reallocation, reallocate_now, set_allowlist, configure_engine_settings, update_engine_settings, get_engine_settings, app_guide, list_apps, set_app, update_app, set_app_memory, remove_app, set_app_env, update_app_env, deploy_app, restart_app, disk_breakdown, app_logs, app_analytics, app_health, app_changes, app_events, ask_app_analytics, set_pull_registry, app_repo, connect_app_repo, list_repos, limit_repos, inspect_repo, import_repo, build_log, list_builds, build_activity, disconnect_app_repo, deploy_latest_build, retry_deploy, rebuild_app, roll_back_app, restart_engine, reset_engine, list_databases, create_database, drop_database, list_extensions, set_extension, postgres_query, postgres_connections, redis_console, redis_keys, redis_key, redis_command, list_streams, create_stream, purge_stream, delete_stream, list_buckets, create_bucket, delete_bucket, list_auth_users, create_auth_user, invite_auth_user, send_auth_link, ban_auth_user, delete_auth_user, rotate_password, set_sql_console, upgrade_instance, downgrade_instance, list_backups, restore_backup, sleep_instance, wake_instance, reset_instance, delete_instance, get_job. Claude Code: `claude mcp add --transport http lathe https://mcp.lathe.live --header "Authorization: Bearer lathe_…"`.
- REST API: https://app.lathe.live/api/v1 ([OpenAPI](https://app.lathe.live/api/v1/openapi.json), [docs](https://app.lathe.live/api/v1/docs)). Every route: GET /me; PATCH /me; GET /billing; GET /plans; GET /locations; GET /instances; POST /instances; GET /instances/{instance_id}; PATCH /instances/{instance_id}; DELETE /instances/{instance_id}; GET /instances/{instance_id}/connection; POST /instances/{instance_id}/access; GET /access; POST /access/{lease_id}/refresh; DELETE /access/{lease_id}; GET /instances/{instance_id}/backups; PUT /instances/{instance_id}/allowlist; PUT /instances/{instance_id}/engines; PUT /instances/{instance_id}/reallocation; POST /instances/{instance_id}/actions/reallocate; PUT /instances/{instance_id}/engines/{engine}/settings; GET /instances/{instance_id}/engines/{engine}/settings; PATCH /instances/{instance_id}/engines/{engine}/settings; POST /instances/{instance_id}/engines/{engine}/actions/restart; POST /instances/{instance_id}/engines/{engine}/actions/reset; GET /instances/{instance_id}/postgres/databases; POST /instances/{instance_id}/postgres/databases; DELETE /instances/{instance_id}/postgres/databases/{name}; GET /instances/{instance_id}/postgres/databases/{name}/extensions; PUT /instances/{instance_id}/postgres/databases/{name}/extensions/{extension}; DELETE /instances/{instance_id}/postgres/databases/{name}/extensions/{extension}; PUT /instances/{instance_id}/redis/console; GET /instances/{instance_id}/redis/keys; GET /instances/{instance_id}/redis/keys/{name:path}; POST /instances/{instance_id}/redis/command; GET /instances/{instance_id}/couchdb/databases; POST /instances/{instance_id}/couchdb/databases; DELETE /instances/{instance_id}/couchdb/databases/{name}; GET /instances/{instance_id}/nats/streams; POST /instances/{instance_id}/nats/streams; POST /instances/{instance_id}/nats/streams/{name}/actions/purge; DELETE /instances/{instance_id}/nats/streams/{name}; GET /instances/{instance_id}/s3/buckets; POST /instances/{instance_id}/s3/buckets; DELETE /instances/{instance_id}/s3/buckets/{name}; GET /instances/{instance_id}/auth/users; POST /instances/{instance_id}/auth/users; POST /instances/{instance_id}/auth/users/actions/invite; POST /instances/{instance_id}/auth/users/actions/send-link; PUT /instances/{instance_id}/auth/users/{user_id}/ban; DELETE /instances/{instance_id}/auth/users/{user_id}; PUT /instances/{instance_id}/sql-console; POST /instances/{instance_id}/actions/rotate; POST /instances/{instance_id}/actions/resize; POST /instances/{instance_id}/actions/downsize; POST /instances/{instance_id}/actions/sleep; POST /instances/{instance_id}/actions/wake; POST /instances/{instance_id}/actions/reset; POST /instances/{instance_id}/actions/restore; POST /instances/{instance_id}/engines/postgres/query; GET /instances/{instance_id}/engines/postgres/connections; GET /instances/{instance_id}/apps; PATCH /instances/{instance_id}/apps; PUT /instances/{instance_id}/apps/{name}; PATCH /instances/{instance_id}/apps/{name}; DELETE /instances/{instance_id}/apps/{name}; POST /instances/{instance_id}/apps/import; PUT /instances/{instance_id}/apps/{name}/env; PATCH /instances/{instance_id}/apps/{name}/env; GET /instances/{instance_id}/apps/{name}/logs; GET /instances/{instance_id}/apps/{name}/analytics; GET /instances/{instance_id}/apps/{name}/analytics/health; GET /instances/{instance_id}/analytics/health; GET /instances/{instance_id}/apps/{name}/analytics/changes; GET /instances/{instance_id}/apps/{name}/analytics/events; POST /instances/{instance_id}/apps/{name}/analytics/ask; GET /instances/{instance_id}/disk; PUT /instances/{instance_id}/registry; POST /instances/{instance_id}/apps/{name}/actions/deploy; POST /instances/{instance_id}/apps/{name}/actions/restart; GET /guides/apps; GET /github/installations; PUT /github/installations/{installation_id}/repos; GET /github/repos; GET /github/repos/{owner}/{name}; GET /instances/{instance_id}/apps/{name}/github; PUT /instances/{instance_id}/apps/{name}/github; GET /builds; GET /instances/{instance_id}/apps/{name}/builds; GET /instances/{instance_id}/apps/{name}/builds/{run_id}; DELETE /instances/{instance_id}/apps/{name}/github; POST /instances/{instance_id}/apps/{name}/github/actions/deploy; POST /instances/{instance_id}/apps/{name}/github/actions/retry; POST /instances/{instance_id}/apps/{name}/github/actions/rebuild; POST /instances/{instance_id}/apps/{nam