Compute
Run governed outbound work for your organization — prepared, parameterized HTTP calls and one-off generic requests — bounded by a layered egress allow-list and Vault credential indirection, so secrets are resolved server-side and never exposed to the caller.
What ships today
Compute v0 ships the APIs family and the standalone compute.http.request capability. The Functions family (managed serverless handlers) and a Browser family are coming soon — their zones and permissions are declared for forward-compatibility, but the endpoints respond 501 for now. Everything in this guide other than APIs and generic HTTP is preview.
Key Concepts
Compute is the platform's executor: it makes outbound calls on behalf of members, agents, automations, and apps, under the same zones, connections, and Vault model the other services use. It is organized as a family of capabilities that share one outbound-call engine and one set of guardrails.
The Compute Family
Two things are live today. APIs are prepared, parameterized calls — think Postman, but governed by the platform. The standalone compute.http.request is the “let this agent just call an API” primitive — a one-off call gated by the org-border compute:http:request capability. The Functions family (serverless handlers on AWS Lambda) and a Browser family are coming soon.
One Engine, One Set of Guardrails
Whether a call comes from an API request or a generic HTTP request, it runs through the same engine: render the final target, check it against the layered egress allow-list, resolve any Vault credential server-side, apply it, make the call, and write an invocation row recording status, timing, egress records, and which credential references were resolved (references only — never values).
Reactions and scheduling are not a Compute concern. Compute is the executor; the central Automations service decides cadence and triggers. An automation step becomes “invoke a Compute request” or “invoke compute.http.request.”
APIs
An API is a federated zone that holds shared configuration plus a set of requests. APIs sit directly under your organization: creating one needs compute:apis:create and mints its zone.
An API Holds Config; Requests Are the Leaves
The API is the unit of shared config: a base_url, variables referenced as {{vars.*}}, default_headers, and the credential_ref its calls are sent with. Each request is a governed leaf — one prepared call with a method, a path (appended to the base URL when relative; an absolute URL must stay under it), headers, query, body, and a params_schema for caller-filled inputs. You grant on the API to cover all of its requests, or on a single request to scope to one call.
An API is not typed by style — REST and GraphQL both compile to a single outbound HTTP call, so the style lives on the request's kind (rest or graphql). This lets one logical integration mix both under one base URL and one credential.
# 1 — Create an API
curl -X POST https://platform.ergondata.ai/api/v1/compute/apis \
-H "Authorization: Bearer {token}" \
-H "X-Company-Id: {company_id}" \
-H "Content-Type: application/json" \
-d '{
"name": "Stripe",
"base_url": "https://api.stripe.com",
"credential_ref": {
"namespace": "{namespace_id}",
"credential": "{credential_id}"
}
}'
# 2 — Add a request (a leaf) with a non-secret param
curl -X POST https://platform.ergondata.ai/api/v1/compute/apis/{api_id}/requests \
-H "Authorization: Bearer {token}" \
-H "X-Company-Id: {company_id}" \
-H "Content-Type: application/json" \
-d '{
"name": "Get invoice",
"method": "GET",
"path": "/v1/invoices/{{params.invoice_id}}",
"params_schema": {
"type": "object",
"required": ["invoice_id"],
"properties": {"invoice_id": {"type": "string"}}
},
"expose_as_tool": true
}'Set expose_as_tool on a request to register it in IAM's tool registry. Its params_schema becomes the tool's args_schema, so agents and automations know exactly which parameters to pass.
Connectors
A connector is an API installed from the connector catalog (GitHub today). In the console, Integrations → Connectors lists the providers; choosing one walks you through three steps: pick how to connect when the provider offers more than one way and fill in its fields and secret, choose what unmapped calls may do (strict mode, allowed methods, denied paths), and review. Installing creates the API, a Vault namespace the API owns, and the credential inside it; the secret goes straight to Vault and is never shown again. For providers that use OAuth sign-in, you are then sent to the provider to authorize, and come back to the connector's page, whose Connection tab shows the connected account. A connector is still an API, so the Compute rail lists it too.
GitHub connects either as a person (Sign in as user, through an OAuth app) or as a GitHub App installed on an organization or account (Install as GitHub App). For the app, enter its client ID (or App ID), the installation ID from the installation's settings URL, and the app's private key. There is no sign-in step: right after installing, Vault reads which account the installation is on, which checks the IDs and the key. Calls then act as the installation, with the repositories and permissions it was granted, and Vault renews its hour-long tokens with the key, which never leaves Vault.
While the connector is attached it owns the base URL, the authentication and the credential reference; they show as Managed by connector. Name, strict mode, methods, denied paths, variables and requests stay editable. Detach turns the connector into an ordinary API and its namespace into an ordinary Vault namespace, keeping the credential. The org's egress allow-list still has to allow the provider's host.
A connector authorized with your account calls the provider as you, and a GitHub App connector as the app's installation. Anyone you share the API with acts as that account or installation through its saved requests and, when the API isn't strict, through direct calls. Allowed methods and denied paths limit direct calls only: a saved request may use any method on any path under the base URL.
Invoking a Request
To run a request, POST to its /invoke endpoint with a params object. These are non-secret, invoke-time inputs — distinct from the API's static {{vars.*}} and from Vault secrets. Params are treated as untrusted caller input: they are validated against the request's params_schema, rendered into the path, query, headers, or body as {{params.*}}, and can never override the auth slots. The final rendered URL must stay under the API's base URL — same host and port, at or below its path — so a param holding .. or another host fails the invocation with base_url_violation before anything is sent. It is then checked against the egress allow-list.
APIs are strict by default: only their saved requests run. Turning strict off (which needs a base URL) lets a caller holding compute:apis:call send a direct call to POST /apis/{api_id}/call with any of the API's allowed_methods (GET and HEAD by default) on a path under the base URL that no denied_paths entry covers. The call uses the API's credential and egress like an invoke. Saved requests are never checked against these methods and paths.
curl -X POST https://platform.ergondata.ai/api/v1/compute/apis/{api_id}/requests/{request_id}/invoke \
-H "Authorization: Bearer {token}" \
-H "X-Company-Id: {company_id}" \
-H "Content-Type: application/json" \
-d '{"params": {"invoice_id": "in_1MqABCdef"}}'Every invoke produces an invocation row you can read back from the Invocations endpoints — with status, timing, egress records, and the credential references that were resolved (references only). For a one-off call that is not part of an API, use the standalone POST /http/request instead, gated by the org-border compute:http:request capability.
Egress Model
Every outbound call — API request or generic HTTP — is bounded by a layered egress allow-list. A target is allowed only if every applicable layer permits the final rendered URL, checked against its resolved IP so a permitted hostname that resolves into a private range is still refused.
- Platform floor (always on). A hardcoded, non-configurable layer that denies private (
10/8,172.16/12,192.168/16), loopback, link-local, and reserved ranges — including the cloud metadata endpoint169.254.169.254. It protects platform internals from SSRF, has no setting, and no endpoint. - Company allow-list (deny by default). One policy per organization, disabled / allow-none out of the box. An administrator must enable it and define the hostname allow-list (specific hosts/suffixes, or
["*"]for all public hosts, still subject to the floor). This is the superset every principal draws from. - Per-principal subset (optional). When the
compute:http:requestcapability is toggled on an agent or automation, that consumer may carry its own allow-list — a subset of the company policy, never a superset. If absent, the principal inherits the company allow-list as-is. This layer applies to one-offcompute.http.requestcalls only; invoking a stored API request or calling an API directly uses the floor and the company allow-list.
# Enable company egress and set the allow-list (admin)
curl -X PUT https://platform.ergondata.ai/api/v1/compute/egress/company-policy \
-H "Authorization: Bearer {token}" \
-H "X-Company-Id: {company_id}" \
-H "Content-Type: application/json" \
-d '{"enabled": true, "allow_hosts": ["api.stripe.com", "*.example.com"]}'
# Restrict a specific agent to a subset of the company list
curl -X PUT https://platform.ergondata.ai/api/v1/compute/egress/principal-policies/{principal_id} \
-H "Authorization: Bearer {token}" \
-H "X-Company-Id: {company_id}" \
-H "Content-Type: application/json" \
-d '{"principal_type": "agent", "allow_hosts": ["api.stripe.com"]}'The per-principal list is intersected with the company policy at save time — entries the company list would not permit are silently dropped, so a per-principal policy can only ever narrow the company allow-list.
Credentials & Vault
Compute never stores secret values. An API names one Vault credential by ID in credential_ref ({namespace, credential}, or null) — a reference only. The secret is resolved at execution time and redacted from logs, invocation output, and audit.
The credential decides how it is sent, from its Vault type and config: an api_key in the header or query parameter its config names (with an optional prefix such as Token), a bearer_token, a JWT Vault signs for a signed_jwt or an OAuth access token as Authorization: Bearer, and basic_auth as Authorization: Basic with its username. To change how a key is sent, edit the credential in Vault. Other types fail the call with credential_unsupported.
Credential Indirection
An API has its own IAM principal. It is created by the first public invoke of a credential-bearing request; internal invoke never creates it. The principal is saved before the egress check, so that first invoke usually fails: with egress_denied while the company allow-list doesn't permit the host, then with credential_denied until Vault access is in place. Once the principal exists, connect it to the Vault namespace and grant it vault:credentials:use on it. At invoke time, Compute resolves the credential as the API's principal, applies it to the call, and redacts it. The triggering caller — an agent holding only compute:apis:requests:invoke — holds no vault:*, never connects to Vault, and never sees the secret. This is the recommended shape for use-without-seeing.
Standalone calls have no indirection
The generic compute.http.request has no API principal to resolve a secret on your behalf. So if a standalone call references a Vault credential, the calling principal itself must hold vault:credentials:use. Resolution is still server-side and redacted — the caller is authorized for the secret but never handles its bytes.
Sharing an API with another principal uses the platform's unified access model: grant on the API zone, or let a consumer raise a connection request that the zone admin approves. For the full lifecycle — principals, grants, connection requests, and runtime enforcement — see the Permissions guide.
Ready to start building? Head to the Compute API Reference for the complete list of endpoints, request parameters, and response schemas.