Resources
Look up any kind in the API here, with all of its fields, defaults and limits. We generate these pages from the same CRDs the API uses to validate your objects, so they match what the API accepts.
billing.etorm.com
BillingAccount
Who pays. Owns projects and receives their usage; its owners can grant access to it.
SKU
A price list entry: the price of one kind of resource per hour of existence, or per unit of what it uses (CPU-seconds, GiB-seconds of storage). Managed by the platform.
Usage
Metered usage of one SKU by one project in one month. Written only by the platform.
compute.etorm.com
Process
A program running as a process: woken by frames on its virtual Ethernet interfaces, by timers it sets and by schedules declared here, idle (and free) in between.
Program
A registered program: a small WebAssembly module that handles Ethernet frames, timers and schedules. Immutable; to change a program register a new one under a new name. Programs the platform registers itself (larger, kept in platform storage) are available to every project.
database.etorm.com
devices.etorm.com
dns.etorm.com
DNSRecord
One DNS record of a zone, as desired state (spec 0051). Made by hand or by the manifest of the zone, or by the zone's inventory (in plan mode) for a record that already existed.
DNSZone
A DNS zone the platform keeps (spec 0051): which zone, with which credential, in which mode and under which policy. The operator inventories the zone into DNSRecord objects (plan mode: nothing changes), then creates what is declared and missing, repairs what it owns and was changed, and reports what is present and declared nowhere.
ZoneSettings
The settings of a DNS zone that decide how clients reach it (spec 0051 section 'Zone settings'): the secure-connection mode, the lowest accepted TLS version and the redirect of plain HTTP to HTTPS. The operator reads them back from the provider on every pass, reports a difference as Drifted and puts the declared value back in apply mode. Only the settings named here are managed.
edge.etorm.com
Certificate
A TLS certificate for names served by an ingress. Its private key never appears in the API: either an ingress node makes its own key and a self-signed certificate for the names (source generated), or the certificate and key are objects you stored in a bucket, which Etorm encrypts (source stored). Only the fingerprint and the expiry are shown. It is Pending until an ingress that uses it runs.
Ingress
An ingress: the entry that accepts traffic and forwards it to targets at L3 (every IP packet), L4 (TCP and UDP ports) or L7 (HTTP and HTTPS with host, path and header rules and TLS termination), on nodes that run as Compute processes on a VPC. It serves once its engine is available; until then it stays Pending with reason EngineNotAvailable. https listeners wait for their certificate.
LoadBalancer
A load balancer: spreads traffic over backends at L3 (IP packets per flow), L4 (TCP connections and UDP datagrams) or L7 (HTTP requests), with health checks, on nodes that run as Compute processes on a VPC. It serves once its engine is available on the platform; until then it stays Pending with reason EngineNotAvailable. Works over IPv6 alone.
PublicEndpoint
A public door onto an ingress, made by the platform team. The gateway named here listens on a TCP port of its own host and relays every connection to the ingress inside its VPC, which then routes it (TLS ends at the ingress, or in front of this door when the name is proxied). When spec.dns is set, the Edge operator reconciles the public DNS records for spec.hostname automatically. Only the platform team can create it.
PublicRecord
The DNS records of one public name, kept by the DNS operator of the platform with the DNS provider API: one A or AAAA record per address, proxied or not. Made from a PublicEndpoint, never by hand. The operator marks every record it makes with an ownership comment and only ever changes or deletes records that carry it (plus, with takeover replace, the records it replaced, which it puts back on removal).
flow.etorm.com
BlockType
A block kind of the visual language: its ports and what it builds. Platform-managed; the canvas reads it.
Diagram
Infrastructure drawn as blocks with typed ports, joined by links. A controller builds what it describes.
graphdatabase.etorm.com
iam.etorm.com
APIToken
A bearer secret for a principal. The secret is shown once at creation and never stored.
Group
A set of principals that roles can be granted to.
Invitation
A one-time link that grants a role to whoever redeems it after signing in.
InvitationAcceptance
The act of redeeming an invitation; creates the role binding. Never stores the token.
ProcessToken
A short-lived bearer secret that lets a process call the API as itself (system:process:<project>:<name>). Made by the machine that hosts the process; the secret is shown once at creation and never stored. The process has no rights unless the platform bound a role to it in the root cluster.
Role
A set of permissions (rules) that can be bound to principals.
RoleBinding
Grants a role to users, groups or service accounts, optionally limited to one billing account.
ServiceAccount
A non-human identity for automation, in the platform or one project.
User
A person known to the platform. People who sign in also work without one.
intelligence.etorm.com
Agent
An always-on agent: a language model that pursues the goal you write, observes this project through the API and acts through it with its own identity, which can do exactly what its role allows. Every step is recorded durably and every action is in the audit log under the agent's name. Text it reads is treated as data, never as instructions.
AgentAction
One action an agent decided on, with its outcome. Written by the platform only; approve or deny one that waits with an AgentApproval.
AgentApproval
A person's decision on an agent's action that waits for approval. Only people can create one; it is used once and cannot be changed.
ChangeProposal
A change to a repository that an automation agent of a swarm proposes: files to put or delete, a title and the reasons. It never writes to the repository itself. The platform checks the paths and sizes against the rules of the proposal's kind, records the plan, and (when the swarm is not in plan mode) makes a branch and opens an ordinary Forge change request for people and the repository's checks to judge, and a ticket card. Written by agents of the swarm only.
Handoff
A message between two roles of a swarm: what the sender found, for whom, and about which object. Its content is data for the addressee, never an instruction.
InferenceEndpoint
An HTTP endpoint for language-model inference in this project, compatible with the Anthropic Messages API and the OpenAI chat completions and embeddings APIs. It forwards to the model provider you choose with the key you keep in a Secret, counts tokens, and applies quotas and per-caller rate limits. Request logging is off unless you turn it on.
InferenceProvider
Where and how a model is called: one account or endpoint of a provider, with its credential. A project may have many, of the same type under different accounts. The platform checks the credential with a free call, lists the models it can use and keeps its health. An InferenceEndpoint names the providers it routes to.
MCPCall
The record of one tool call on an MCP endpoint: who called, which document (by hash and operation name, never the text of secret values), what it touched and how it ended. Written by the platform only and never changed; kept for the endpoint's retention period.
MCPCredential
A credential for one MCP endpoint: a token that works on that endpoint only and nowhere else in the API. The token is shown once, when this object is created; to rotate, create a new credential, move the client over, then delete the old one.
MCPEndpoint
A Model Context Protocol server for this project that gives an AI client two tools only: search the project's API, and run one GraphQL document against it. It acts as a named service account, so it can never do more than that account may; make one endpoint per client and per purpose. Clients connect over Streamable HTTP with a token of an MCPCredential.
Memory
Agentic memory: documents cut into chunks with embeddings and metadata, searched by similarity together with keyword and metadata filters. Shared by the project or kept for one agent, kept in Etorm storage, erased when deleted.
ModelProvider
Who makes models (Anthropic, OpenAI, Google, DeepSeek, Meta, Mistral, ...) and the catalog of what they make: families, capabilities, context windows, modalities, published prices and deprecation dates. It holds no credentials. The platform keeps a shared catalog; a project may add its own. The status adds the models that InferenceProviders report they can serve.
RemediationProposal
An agent's proposal to change the platform: one of the platform's bounded remediation actions on one object, or a new remediation policy. An agent never acts itself: an approved proposal becomes a Remediation that the platform's own controller runs with its budgets and records.
Swarm
A swarm of platform agents with fixed roles (triage, investigator, fixer, reviewer, librarian) that keeps the platform healthy above the automatic remediation: they read the platform, hand work to each other and propose actions; the platform's own remediation carries them out. Only in the platform's agents project. Starts in plan mode.
limits.etorm.com
monitoring.etorm.com
AlertRule
A real-time threshold or anomaly alert evaluated over a TelemetryStream (spec 0042).
LogStream
Every log stream of one source (a station or a platform Worker), captured into a Monitoring workspace, and its health: lag, last sequence numbers, gaps and drops (spec 0042 "Platform logs").
MonitoringDashboard
A real-time Monitoring dashboard over TelemetryStreams (spec 0042).
MonitoringWorkspace
A real-time Monitoring workspace backed by columnar Object Storage and Edge Compute shards (spec 0042).
TelemetryStream
A real-time stream of logs, metrics/APM, distributed traces, or network traffic flows (spec 0042).
network.etorm.com
AccessPoint
A station that is the member endpoint of the VPCs without a gateway (spec 0038 section 28): a customer's member machine ends its WireGuard tunnel here, and the station attaches it to the VPC's Ethernet segment itself. Written by the cloud operator, one per station with station.access and no hub (the spec); the network controller fills the status with every member and VPC the station must serve. Root cluster only; customers see only their Account's status.accessPoint.
Account
One member's attachment to a VPC: its key, addresses and the configuration to join.
DHCPService
DHCPv4 for one VPC: addresses for members and for other devices, with routers, DNS and a domain.
DNSService
An authoritative DNS server for one zone inside one VPC; members are registered automatically.
Device
A device on a VPC as its gateway sees it: an account's member, a Compute process interface, or any other MAC address with a neighbor entry. Created, updated and removed by the gateway agent; informational.
Device
An enrolled MCU device connected to the project's Kubernetes API (spec 0044).
DeviceEnrolment
A one-time enrolment code for a phone (spec 0041): whoever holds the code may, until it expires, create exactly one Account of this name in this VPC (access station, only the public key free) and read it back. The code is shown once in the create response and stored only as a hash. The object is named like the Account it allows.
Gateway
The attachment point of members to the platform's switch: WireGuard endpoint and tunnel network. Platform-managed.
GatewayPeer
A plain WireGuard peer of a Gateway: a host that is not a VPC member (an external node, spec 0038) and needs a tunnel address on the gateway's network and a place in the gateway's peer table, with no L2 device. The address is allocated at once and never changes; the peer joins the table when its public key is set. Created by the platform's operators.
Subnet
An address range (a prefix) on a VPC's Ethernet segment. Every VPC has a default subnet, named <vpc>-default, with the VPC's own prefix; members that name no subnet are in it. A subnet is an addressing and routing construct, not a security boundary: all members of a VPC share one segment; separation needs separate VPCs.
VPC
A private Ethernet segment. IPv6 /64 always, IPv4 optional; members attach through accounts.
VPCObservation
When a gateway last looked at one VPC and which one it was. The devices it saw are Device objects. Written by the gateway agent, informational only.
platform.etorm.com
Approval
A person's recorded decision that automatic loops may not make for themselves (a new trust anchor, a freeze, a gate waiver, an override, a custody check). Only a user principal can create one; service accounts, processes and platform components cannot. It never changes after it is made; delete it to withdraw it. Only in the root cluster and in system projects.
BackupVerification
Whether the newest backup of a store was opened with the store's key and found restorable, and how long ago (spec 0036 'Backups', spec 0047 section 8). The status is kept from the manifest the backup Worker writes next to every export; Ready is false when the verification failed or is older than maxAgeSeconds.
BootstrapRequest
What an automatic controller asks of a person: a new external credential or trust, why, for which object, and the exact steps. It is raised as an Incident and completed when a person approves it (an Approval of type Bootstrap by someone other than the requester) and the named secret has a fresh version. Only in the root cluster and in system projects.
CapacityPolicy
Turns a measured resource into an action before its limit (spec 0047 section 8): the value of a number in an object, as a fraction of the tested ceiling, warns at one threshold and, at the next, creates a request object from a template within limits and a spending budget. Above the budget nothing is created and an Incident asks a person.
ControllerPlacement
How many instances of one of the platform's controllers must exist, on which classes of machine, and with which program. The placement controller creates the Compute processes, spreads them over distinct machines and replaces an instance whose machine or heartbeat is lost. Platform processes only.
DeployedVersions
What the platform deployed and when, generated from the histories of its releases (spec 0047 section 3): the one record of what runs, so nobody writes it by hand. The release controller keeps the status; there is one object, `platform`.
Host
One machine of the platform and what it must run. The agent on the machine starts on boot, reads this object and makes the machine match it: it starts what is missing, makes the gateway container carry its endpoint address and run the gateway agent, and joins the member containers to their VPCs. It reports what it found, and a coarse heartbeat.
Incident
The only way the platform asks a person for help: opened by a controller when it has done what it is allowed to do or needs something only a person can give (spec 0047 section 6).
Intent
What one product of the platform needs to be true, as an ordered list of links (resources that must be Ready and public probes that must pass). The platform computes whether it holds and, when it does not, names the first failing link.
Invariant
A property of the platform stated as a read-only openCypher query over the graph of API objects: the query returns the violating objects, and zero rows means the invariant holds (spec 0047 section 6.5). The platform evaluates it when a kind it reads changes and every 30 minutes, within a row and work budget.
Lease
The right of one instance to act as the single active instance of a controller (the cloud operators of an account, the release controller, the capacity controller). A claim is a write: it is refused while another holder's lease has not run out, so of two racing claims one fails.
LiveStatus
What a host of the platform's controllers is running and whether each controller passes (spec 0047 section 6.5). Written by the host, never by a person: one object per host, one entry per controller registered, with its last pass and last error, and the outcome of the dry run of the safety mechanisms the host carries.
PlatformRelease
The desired build of every component of the platform, for one commit. The active release is what the platform converges to: gates first, then each component through a canary, a bake and a promotion, with automatic rollback when its objective burns (spec 0047 section 3).
PlatformTopology
The stable shape of the platform (spec 0047 section 3): which components exist, which hostnames reach each, what each depends on and how each is rolled out. It does not change with a commit; a PlatformRelease only says which build of each component is wanted, and the release controller merges the topology into every release, so every platform hostname is desired state.
ReleasePolicy
When a run of the platform's workflow on a branch ends successfully, the release of that commit is made, with no person in between (spec 0047 section 3). The policy says which components may be released by themselves, how many releases may roll out at once and per hour, and how long to hold a commit first. Only components whose build differs from the last release that finished them are released; the release controller activates the newest release whose gates are green.
Remediation
What the platform may do by itself when a condition holds: one bounded action, with a budget, a backoff and a cooldown (spec 0047 section 6). When the budget is used up an Incident is opened.
RemediationAttempt
One attempt of a Remediation on one target, kept as a bounded ring per policy (spec 0047 section 6).
SLO
A service level objective: how often a product must be good, measured over a window, with the error budget and burn rates computed from samples (spec 0047 section 6).
Scenario
An incident kept as a permanent test (spec 0047 section 6.4): a small reference to the recorded slice of the object graph on the failing Intent's dependency path, with its provider read-backs and probe results and every secret stripped. The slice itself is a compressed document in the platform bucket, never state in the store.
StoreStat
How big a store of the platform is, as an object a CapacityPolicy can measure (spec 0047 section 8). The numbers come from the store itself, never any of its content; the capacity controller refreshes them about once an hour or when the size moved by five percent.
Watchdog
The watch over a component that runs the release controller itself (spec 0047 section 3 'Not being able to roll itself back'): a bad build of it has nothing behind it to roll it back. The component's own Worker writes a heartbeat on each pass; a pass in another Worker reads it, and when a new version took all the traffic and the heartbeat stays away for the grace time it moves the traffic back to the previous version, once, asks the active release to record it and opens an Incident.
queues.etorm.com
resourcemanager.etorm.com
Project
An isolated logical cluster with its own API endpoint, billed to one billing account.
Workspace
A unit of ownership and trust. It holds projects and child workspaces, is linked to one billing account, and has its own owner: whoever creates it receives the owner role in it and in everything below it, and nothing above it or beside it.
secrets.etorm.com
CredentialDelivery
A credential the platform makes and puts where a platform component reads it, so nobody pastes it. The source is an API token for a service account, a generated random value, or a Secret; the target is a secret of a platform component. The operator never shows or stores the value: it goes from its origin to the target in one step, the old token is revoked after the new one is delivered and a grace period has passed, and the status shows only a fingerprint and times. Starts in plan mode. Only in the root cluster and in system projects.
ProviderToken
The permissions of an API token the platform uses at an outside provider, as desired state. Every pass the operator reads the token's live permissions back and reports the difference from what is declared here; in apply mode it adds the declared permissions that the allowlist and the platform's fixed safe list permit, and removes only what the remove list names. Starts in plan mode. Only in the root cluster and in system projects.
Secret
A held secret, such as a cloud credential, a TLS private key, a signing key or a deploy token. The value is write-only (it can be created and replaced, and no get, list or watch returns it), is sealed in the store under a per-project key, and is delivered only by the audited reveal path or into a sandbox that references the secret. Status shows metadata about the value (version, fingerprint, expiry, consumers), never the value.
SecretBinding
Names a principal (an operator, a node agent, a runner's service account) that may receive a secret through the reveal path. It grants nothing by itself, because the principal also needs the reveal right of the secret-revealer role. Two locks, both required.
SecretKey
The data key of one project, wrapped under the platform key. Made by the platform with the project's first secret; clients cannot create or change it. Deleting it destroys every secret of the project for good (crypto-erase), so it is refused while secrets exist.
storage.etorm.com
Bucket
A bucket of objects. Objects are encrypted by Etorm and read and written over HTTPS with an API token that has access to the bucket. Deleting a bucket makes every object in it unreadable at once.
PlatformBucket
A bucket the platform itself keeps at its storage provider (a website's files, backups, the shards behind Storage): its place, settings, lifecycle rules, cross-origin rules and public access as desired state, adopted when the bucket already exists, with every difference reported. Only buckets named etorm-... can be described, so a bucket that is not the platform's is never touched. In plan mode nothing is changed at the provider.
workflow.etorm.com
WorkflowActivity
Defaults for an activity type that workflows call: its task queue, timeouts and retry policy, used when a workflow's call leaves them out, and the last execution the engine reports. The code of the activity is in the workers; one execution of it is recorded in the history of the workflow that called it.
WorkflowNamespace
The isolation and billing unit of Workflows: durable workflows written in Rust and compiled to WebAssembly, their activities, task queues, timers and schedules, with every byte kept in Etorm storage. Workflows are offered by invitation; until the engine is enabled for the project, a namespace stays Pending with reason EngineNotAvailable and nothing is billed.
WorkflowSchedule
Starts a workflow at times given by cron expressions or fixed intervals, with a policy for runs that overlap and for times missed while the engine was down.
WorkflowType
Defaults for a workflow type: the task queue, timeouts and retry policy used when a start request leaves them out. The code of the workflow is in the workers, not here.