Serverless functions.
Event-driven functions that scale to zero — run code and agents without managing a server.
Deploy a function, get an endpoint. Functions scale from zero to thousands of concurrent invocations on demand and bill only for execution time — ideal for glue, webhooks and agent tool calls.
- Category
- Compute
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Scale-to-zero functions are commodity. Where the function can reach is not.
Every cloud runs event-driven functions that scale to zero and bill per invocation — that's solved, and Aether matches it: JS, Python and containers, triggered by HTTP, queues, the event bus, storage changes or a schedule, with provisioned concurrency where cold starts matter. The differentiator is reach. A function's most common job in an AI app is a tool call or a piece of inference, and on Aether that's a local call because the model is on the same platform — not an egress to an external API.
The natural home for agent tool calls.
The Aether SDK is preinstalled, so a function is the obvious place to implement a capability-gated agent tool: it runs only when invoked, scales with demand, and reaches the model, the vector store and your data without leaving the boundary. The thing the agent runtime calls and the model that calls it share one identity and one audit trail.
Pay for the work, deploy in your boundary.
Nothing runs and nothing is billed when idle; concurrency scales to thousands per request and back. And like the rest of the catalog it deploys managed, in your VPC, on-prem or air-gapped — so even the glue code runs where your data is allowed to live.
An agent tool as a function: invoked on demand, reaching the model and your data without leaving the boundary.
export default aether.fn(async (req) => {
const { query } = await req.json();
const docs = await aether.vector.search("kb", query, { topK: 5 });
return aether.generate({ model: "aether-7b", input: query, context: docs });
}); // scales to zero · capability-gated · in your boundaryThe function does retrieval and inference as local calls on the same platform. On Lambda the model and the vector store are external services, so the same tool is two egress calls and a wider trust boundary.
Three steps to running.
Push a handler in JS, Python or a container; no server, runtime or scaling config to manage.
Wire HTTP, a queue, the event bus, a storage change or a schedule to invoke it.
Concurrency scales from zero to thousands per request and back; you pay per invocation.
Serverless functions, in full.
No idle cost; cold starts kept low with provisioned concurrency where latency matters.
Triggered by HTTP, queues, the event bus, storage changes or a schedule.
First-class JavaScript, Python and containers, with the Aether SDK preinstalled.
Pay per request and millisecond — nothing when idle.
Provision it in a few lines.
Every service is reachable from the same SDK, CLI and infrastructure-as-code — one identity, one bill, one audit trail across the whole catalog.
# Provision serverless functions on Aether Cloud
aether compute create \
--service serverless-functions \
--name app \
--region us-1 \
--deploy managed # or vpc | on-prem | air-gappedAt a glance.
- Runtimes
- JS · Python · containers
- Scaling
- 0 → thousands, automatic
- Billing
- Per request + ms
- Cold start
- Low; provisioned concurrency available
- Triggers
- HTTP · queue · event · schedule
Built for real work.
Agent tool and function calls
Webhooks and lightweight APIs
Event-driven data processing
On one model, not stitched together.
The usual stack runs serverless functions in one product, the model in another and the data in a third — and the seams between them are the cost. Aether Cloud runs it on the same platform that serves the model, governs your identity and deploys into your boundary, with the rest of the catalog one hop away.
No stitching a vector DB to one place, a warehouse to another and a model to a third — serverless functions sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your serverless functions — so the data and the model never leave the same governed boundary to talk to each other.
Need a capability that isn’t here yet? The model writes and deploys it into the same boundary — the catalog is a starting point, not a ceiling.
Good to know.
Same event-driven, scale-to-zero model — but co-located with the Aether model, so agent tool calls and inference stay in one boundary.
Cold starts are kept low, and provisioned concurrency pins warm capacity where latency matters.
Yes — the Aether SDK is preinstalled, so a function is a natural home for tool calls and lightweight inference.
Your boundary, your choice.
Pairs well with.
On-demand and reserved VMs across CPU and GPU shapes, with per-second billing and live resize.
Latest-generation accelerators by the hour or the cluster, with fast interconnect for training and high-throughput inference.
Managed container runtime with autoscaling, health checks and rolling deploys — bring an image, get a URL.
A conformant, managed control plane with GPU scheduling, autoscaling node pools and zero-downtime upgrades.
Massively parallel batch and simulation jobs with scheduling, checkpointing and fault tolerance built in.
Dedicated single-tenant hardware for the workloads that need full control of the silicon.
Run Serverless functions on Aether Cloud.
Event-driven functions that scale to zero — run code and agents without managing a server. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.