The substrate everything else stands on.

Platform Foundation is the always-on layer every application runs on: request routing, identity and authorisation, real-time data, durable workflows, the database, observability and tenant isolation.

Talk to our team What it does

Written once, enforced everywhere #

These are the parts nobody buys and everybody needs. Get them wrong and every application above pays for it, in duplicated authorisation logic, lost background jobs, stale interfaces and tenancy bugs that only appear in production. The organising idea here is that important decisions should exist in exactly one place: identity resolves to a single authorisation verdict, so a request gets the same answer whether it arrives over a real-time connection, over REST, or as a tool call from an agent.

Interfaces stay live because the database's committed changes fan out as a stream. A client subscribes to a query and receives a snapshot and then diffs, so the screen reflects the system rather than the last time somebody pressed refresh.

Adding a protocol adds a caller, never a second policy engine.

What the Foundation provides #

Four ideas carry the layer. Everything else is detail.

One authorisation decision #

Role, capability and attribute rules collapse into a single audited verdict, and tenant scope is derived server-side from validated credentials rather than a client hint.

Your OIDC provider, federated
Sessions, signed tokens and revocable access tokens
Directory sync for membership

One application, three protocols #

Real time, REST and the tool protocol are generated from one definition, so a new operation appears on every path with the same access rules.

Live queries with snapshot and diff updates
Generated REST facade with server-sent events
Model Context Protocol per application

Work that survives a restart #

Anything that must not be lost halfway through replays from its last committed state after a restart, with side effects committed exactly once.

Durable execution with replay
Timers that fire across failovers
Exactly-once external effects

Live by default, observable by default #

Committed database changes fan out as the stream behind every live query, and every service arrives with its metrics, dashboards, alerts and traces already wired in.

Highly available, horizontally scalable database
Change streaming behind every live query
Metrics, dashboards and alerts ship with the feature

One operation, three ways to call it #

An application declares an operation once. These are the three surfaces the platform then publishes, and all three resolve the same authorisation verdict for the same caller.

rest

curl https://agentycs.example.com/api/apps/inspections/rest/queries/open_findings \
  -H "Authorization: Bearer $AGENTYCS_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"site_id": "FAW-014"}'

Authenticated application traffic lives under /api/apps/{app}/. Anything the application chooses to publish openly lives under /api/public/apps/{app}/ instead.

live

curl -N https://agentycs.example.com/api/apps/inspections/rest/queries/open_findings \
  -H "Authorization: Bearer $AGENTYCS_API_TOKEN" \
  -H "Accept: text/event-stream"

event: snapshot
data: {"rows": [{"site": "Fawley", "open_findings": 12}]}

event: diff
data: {"changed": [{"site": "Fawley", "open_findings": 11}]}

Ask the same operation for an event stream and you get the current answer once, then only what changed. A browser gets the same subscription over the realtime socket, authenticated from its session cookie rather than a token.

mcp

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "inspections.open_findings",
    "arguments": { "site_id": "FAW-014" }
  }
}

Each application has its own tool endpoint at /api/apps/{app}/mcp. A model calling this tool passes the same per-operation permission check as the two calls above.

In more detail #

The full capability surface, grouped by the job it does.

Gateway and application runtime

The hub of platform traffic, and the home application logic runs in.

Application gateway: Authenticated and public traffic is forwarded to the right application with circuit breaking, timeouts, request-id propagation and a deterministic error taxonomy.
Durable actor runtime: Applications are hosted as long-lived actors with mailboxes and timers, so stateful orchestration does not leak across handlers.
Application registry: The catalogue of applications, routes, tenancy mode and exposure that routing, navigation and discovery all read from.
Public and private surfaces: An application can expose authenticated and public routes side by side, each with its own access rules.

Identity and authorisation

Federated identity and a single centralised verdict for every request.

Your identity provider: Each tenant's own OIDC provider is federated in, so people sign in with the credentials they already have, and users are provisioned and de-provisioned from your directory.
Sessions and tokens: Secure browser sessions, plus signed bearer and capability tokens with published verification keys for internal calls.
Personal access tokens: Long-lived programmatic credentials stored only as hashes, exchanged for short-lived tokens, revocable immediately and never carried in a URL.
One authorisation engine: Role, capability and attribute rules resolve to one canonical decision, consolidating every access check in one auditable place.

Protocols and real time

Every application reachable in the way each caller prefers, with identical authorisation on all of them.

Live queries: Clients subscribe to a query and receive snapshot-plus-diff updates in real time as the underlying data changes.
Generated REST facade and tool protocol: A REST API over every application's queries and mutations, including live subscriptions over server-sent events, and a per-application Model Context Protocol entry point, all generated from one definition and kept in authorisation parity.
Fail-closed admission: Session or bearer authentication, application access, tenant context and cross-site origin are all validated before a real-time session is accepted.
Per-session backpressure: Traffic is paced per session with slow-consumer isolation, so a burst for one client does not become everyone's latency, and modern transports fall back transparently.

Durable workflows

Long-running work that survives restarts, failures and failovers.

Durable execution: Status, queues and retries are persisted, so a workflow replays from its last committed state after any restart.
Timers and scheduling: At-time and after-interval triggers fire reliably across restarts and failovers.
Exactly-once effects: Each external call or write commits its outcome before anything downstream can observe it, so effects happen once and only once.
Addressable by identity: Messages route to a workflow by its identity, so orchestration stays stateful without a coordination service bolted on.

Platform database

The transactional tier every live query and change feed flows from.

Highly available PostgreSQL: A managed cluster with a primary and synchronous standbys that promote automatically on failure.
Horizontal scale: Tables are distributed and colocated by tenant, so the database scales out while each tenant's data stays together.
Change streaming: Every committed change fans out over the messaging fabric. This is the engine behind live queries and the lakehouse change feed.
Safe migrations: Idempotent, immutable migrations applied deterministically, with drift repaired by new migrations rather than edits to old ones.

Observability and multi-tenancy

A unified view of platform health, and a private, server-enforced slice of every service per tenant.

Metrics, dashboards and alerts: Services publish metrics onto the messaging fabric and one exporter aggregates them, and every observable change ships its matching dashboard and alert rule, versioned with the platform.
Tracing and real-user telemetry: Distributed traces correlate a request across services, and browser performance and errors arrive through a hardened proxy into the same fabric as server-side signals.
Server-enforced scope: Every service derives tenant scope from validated session or token state, never from client-supplied headers, hostnames or hints, and tenants are provisioned and cleaned up declaratively.
Per-tenant capacity and isolation: Database, search and inference capacity is composed per tenant where needed, and row-level security plus mediated data access mean even shared services cannot read or write across a tenant boundary.

What it gives the products above it #

Foundation is the reason the rest of the platform behaves consistently.

Consistent access control

Data queries, model calls, application operations and agent tool calls all resolve through the same authorisation decision and audit trail.

Work that cannot be lost

Ingestion, model deployment, tenant provisioning and application rollout all run as durable workflows with exactly-once effects.

Operability from day one

Every service arrives with metrics, dashboards, alerts and traces already wired into one fabric.

Interfaces and standards #

The Foundation deliberately speaks protocols your existing tools already know.

OIDC
SCIM and directory sync
Bearer tokens and JWKS
Real time, REST and MCP
Kubernetes resources

What each interface gives you

OIDC: Federate your own identity provider for sign-in, with authorisation, callback and refresh handled by the platform.
SCIM and directory sync: Provision and de-provision users from your directory, so membership stays accurate automatically.
Bearer tokens and JWKS: Signed bearer and capability tokens with published verification keys, plus revocable personal access tokens for automation.
Real time, REST and MCP: Live queries and mutations over a real-time connection, a generated REST facade with server-sent events, and a tool-protocol endpoint per application.
Kubernetes resources: Tenants, applications, databases and platform configuration as declarative custom resources reconciled by the platform operator.

Look under the platform

If you are evaluating Agentycs seriously, this is the layer to interrogate. Bring your identity, tenancy and resilience requirements and we will walk through them.

Talk to our team