The cloud your AI agent can run.
altengine is a managed cloud platform with an MCP server in front of all of it. Connect an agent and it can provision a database, deploy a function, host a site, and read what failed — the same tools you would use in the console, priced by what it uses.
No credit card to start · First $3 free every month · Billing, keys and members stay human-only
you a waitlist page: sign-ups saved, a nightly
export, hosted somewhere I can link to
agent whoami org acme · write
create_instance datastore app ✓
create_instance auth users ✓
auth_set_rules signups: own rows ✓
functions_deploy nightly 0 3 * * * ✓ v1
static_deploy ./dist ✓
live at https://waitlist-web.altengine.app
sign-ups land in app/signups; the export
runs at 03:00 and writes to blob files/One endpoint. Any MCP client.
Give an agent the endpoint and it discovers the rest. A hosted client signs you in; an unattended one carries a key. Either way you choose the organization it acts on and how much it may do: read, write, or full.
claude.ai and Claude Desktop
Add a connector, paste the endpoint, sign in. Pick the organization and the access level on the consent screen and the connection is live.
https://api.altengine.net/mcpClaude Code
Add the server once, then run /mcp inside Claude Code and sign in when it asks. It builds against your organization from the terminal.
claude mcp add --transport http altengine \
https://api.altengine.net/mcpAny client, unattended
For an editor extension or a script nobody is watching, create an API key with MCP / AI agent access switched on and send it as a bearer token.
{ "mcpServers": { "altengine": {
"url": "https://api.altengine.net/mcp",
"headers": { "Authorization": "Bearer ae_…" }
} } }Rehearse locally first. altengine dev serves the same endpoint at http://127.0.0.1:9191/mcp with the same tool names and argument spellings, so an agent can create instances, write data and deploy functions without any of it touching your live organization, then replay the identical calls against the hosted service. How the emulator fits in.
Every service, as tools
The console's capabilities are the MCP tools. An agent can create, configure and delete an instance of any service, then do the work inside it. The same services answer plain REST calls from your code, so what the agent builds is what you would have built by hand.
Datastore
JSON documents with a real query engine: filters, joins, grouped aggregates, transactions, point-in-time restore.
Put and query documents, run an aggregate, declare an index, list what is there.
Search
Full-text search with App Engine's query language, field types, facets and sorting.
Put documents, read the schema, query. The grammar ships inside the server, so the agent reads it before writing one.
Auth
Your app's own end users: password, emailed code, 2FA and passkeys, with short-lived identity tokens.
Create users, set claims, and write the row-level rules that let a browser call Datastore and Channel directly.
Channel
Realtime pub/sub. One WebSocket carries many channels; publish from a server or a token that allows it.
Publish a message, list rooms, check who is present.
Blob
Files uploaded straight to storage over a signed link, published on a subdomain, with bandwidth nobody meters.
Put, get, list, delete, make public, or sign an upload link for a client.
Functions
Sandboxed JavaScript on its own URL, with secrets, cron schedules, an outbound allowlist and scoped clients for the other services.
Deploy a version, schedule it, read the error groups, roll back.
Containers
A Docker image you choose, run as a background job for as long as the work takes.
Start a job, tail its logs, cancel it, pick a size.
Automation
Scripts on your own Windows machines, driving desktop applications and portals the internet cannot reach.
Enrol a machine, learn a task from a recording or the live screen, save the script, put it on a schedule.
Static
Hosting for the built front end on a subdomain or a custom domain, served from the edge, bandwidth not metered.
Deploy a directory, list deployments, make any of them live.
Mailbox
Email addresses for your app or agent: mail arrives as JSON, can call a function or publish to a channel, and can be answered.
Pick an address, wait for a verification code, read and reply.
Tasks
Queues of work delivered to a function, a channel or a webhook and retried until done, fed by your code or by datastore writes, uploads and mail.
Create a queue, add tasks, see why one failed and run it again, or lease work as a pull worker.
Designed to be driven, not just reachable
An API an agent merely can call still costs it a dozen wrong guesses. These are the parts that make the first call the right one.
Names, not ids
Anywhere a tool asks for an instance, the name from list_instances is accepted. Nothing to look up and carry around between calls.
A wrong argument is an error
An argument the server does not recognise is refused, and the reply names the valid ones. It never ignores it and returns an answer that looks right.
The docs ship inside the server
Resources the agent reads on demand: the search and datastore query languages, how auth rules combine, the function handler shape, the automation script API. No guessing at syntax.
Prompts for the multi-step work
Scaffold a backend-less app, add a scheduled job, automate a desktop task: each is a prompt that hands the agent the plan, in the order the steps have to happen.
Stateless, so nothing to reconnect
Every call carries its own credential and is answered on its own. There is no session to keep alive and no handshake to redo after a pause.
The same endpoint locally
The emulator serves the cloud tools under the same names, apart from static, automation and desktop. Work it out against localhost, then run the identical sequence against your organization.
Exactly the access you chose, and never governance
The agent builds. People govern.
A connection is one organization at one access level, and that is the whole of what it can do. A key can be cut finer still, down to a single instance. What no credential can reach, at any level, is the part of the account that should only ever change by a person's hand.
- read looks at everything and changes nothing; write creates instances, writes data and deploys; full can also delete
- Destructive tools need an explicit
confirm: trueon top of the level - No tool for billing, members, API keys or closing the organization, and no scope that could grant one
- Revoke a connection in Settings; membership is re-checked on every call, so leaving an organization ends its access immediately
- Looking at a live desktop needs a developer window an owner opens, and the machine shows a notice the whole time it is open
- Connected application
- Claude Code
- Organization
- acme
- Access
- writeread everything · create instances · write data · deploy
- Not available at any level
- billing · members · API keys · close organization
- Revoke
- Settings → Connected applications, effective on the next call
Still just HTTP and JSON
What the agent builds runs on the same REST API your own code calls. One host, one bearer token, JSON in and out, and no client library standing between you and the service.
The browser talks to your data directly
Static serves the built site, Auth signs the user in and hands the browser a short-lived identity token, and that token goes straight to Datastore and Channel. The row-level rules on the auth instance decide what each user may read and write, so the common shape of an app needs no backend from you at all.
- No API key ever ships to the client
- Rules are configuration an agent can write, not code you keep in sync
- No idle cluster: a namespace you are not touching costs only its storage
- One organization, one bill, every service on it
// in the browser, as the signed-in user
fetch("https://api.altengine.net/v1/datastore" +
"/app/ns/acme/col/signups/query", {
method: "POST",
headers: { Authorization: `Bearer ${idToken}` },
body: JSON.stringify({
where: [{ field: "status", op: "=", value: "waiting" }],
limit: 25
})
})An agent session costs less than a cent
Tool calls are metered at $0.02 per 1,000. Connecting, listing tools, reading resources and getting prompts are free. Work a tool does bills to its own service at the normal rate, exactly as the same call over REST would. The first $3 of usage every month is free across everything, with no card to start.
See the ratesPoint an agent at altengine
One endpoint to connect, the access level you choose, and every service as a tool from the first call. Start free and grow into pricing that stays honest.