Home › Agent Harness › Architecture map

AI · Agent Harness

Agent harness architecture map: what fills each concern, on every stack

An agent harness is the same set of concerns whatever you build it on: a loop, a model door, tools, state, waits, identity, records, configuration. What changes between Azure, Databricks, AWS, GCP and an open-source stack is only the product that fills each one. This page puts all of them on one view, with a verdict on what to pick.

Written 20 November 2026 from the open stack files, one per platform. Open Stack is the only column that has run end to end. Azure and AWS are decided in writing and not yet built. Databricks is part built. GCP has no stack file at all: that column is a proposal, shaded grey, to be checked before anyone relies on it. Product names and features change; check current documentation.

The map

Agent harness17 ports, one binding eachThe loop and where it runsControl loopHostingModelsModel accessAdmission and limitsCost accountingTools and knowledgeTool runtimeRetrievalState and long-running workStateWorkflowApprovalTriggerChannelTrust and policyIdentitySecretsPolicyObserve, record and proveTelemetryRecorderEvaluation entry pointRelease and configurationConfigurationAgent registry

The table

One row per concern. Read across to see what each stack uses. Read the last column for what to select.

Cloud service the platform sells itOpen source a product you can run anywhereBuilt by us a few lines of our own, identical on every stack

built and run: it has run in a real builddecided, not built: chosen in a stack file, no running agent yetproposed: written for this page, no stack file

Concern familyConcernAzureDatabricksAWSGCP (proposed)Open stackVerdict: what to select
The loop and where it runsControl loopWho owns the step budget, the no-progress check and the cost ceiling.Built by us
Our bounded loop in a containerdecided, not built
Built by us
Our bounded loop, wrapped in the Agent Framework interface so it can be traced and loggeddecided, not built
Built by us
Our bounded loop in a container on ECS Fargatedecided, not built
Built by us
Our bounded loop on Cloud Runproposed, no stack file
Built by us
Our bounded loopbuilt and run
Build it, the same on every stack. A loop you did not write cannot be made to stop where your specification says. Cloud agent runtimes can wrap it; they should not own it.
HostingWhere the agent, its tool servers and the review desk run.Cloud service
Container Appsdecided, not built
Cloud service
Lakeflow job for batch work; Databricks App for an interactive deskdecided, not built
Cloud service
ECS with Fargate (App Runner is closed to new customers; Lambda cannot hold a long wait)decided, not built
Cloud service
Cloud Runproposed, no stack file
Open source
Containers from a compose filebuilt and run
Use the container platform of the cloud you are already on. On Databricks a job fits batch investigations.
ModelsModel accessThe one door every model call goes through: keys, limits, usage records.Cloud service
API Management as the AI gatewaydecided, not built
Cloud service
Foundation Model APIs; AI Gateway on top where a serving endpoint is allowedbuilt and run
Cloud service
AgentCore Gateway in front of Bedrock or other providersdecided, not built
Cloud service
Apigee or API Gateway in front of Vertex AIproposed, no stack file
Open source
LiteLLM proxybuilt and run
Use the gateway of the cloud where the models and the data sit. Use LiteLLM when no enterprise gateway exists. One enforcement point per path.
Admission and limitsHow many calls run at once, who waits, who is turned away.Built by us
Semaphores in the harnessdecided, not built
Built by us
Semaphores in the harnessdecided, not built
Built by us
Semaphores in the harnessdecided, not built
Built by us
Semaphores in the harnessproposed, no stack file
Built by us
Semaphores in the harnessbuilt and run
Build it. A few lines of your own beat any product, and it must see the unit of work.
Cost accountingSpend added up per task, with a ceiling that stops work.Built by us
Per-task meterdecided, not built
Built by us
Per-task meterdecided, not built
Built by us
Per-task meterdecided, not built
Built by us
Per-task meterproposed, no stack file
Built by us
Per-task meterbuilt and run
Build it. Cost per successful task needs your definition of successful. Cloud billing tables are a cross-check.
Tools and knowledgeTool runtimeHow a tool call is run, under whose authority.Open source
MCP clientdecided, not built
Cloud service
Unity Catalog functions: typed, permissioned, no free SQL from the modelbuilt and run
Open source
MCP clientdecided, not built
Open source
MCP clientproposed, no stack file
Open source
MCP clientbuilt and run
MCP everywhere. On Databricks, register the data tools as Unity Catalog functions so permissions and lineage come with them.
RetrievalTurning a question into passages the caller is allowed to see.Open source
pgvector in the same PostgreSQLdecided, not built
Cloud service
Vector Search; embeddings in Delta plus a function where Vector Search is refuseddecided, not built
Open source
pgvector in the same RDS PostgreSQLdecided, not built
Open source
pgvector on Cloud SQL or AlloyDB, or Vertex AI Vector Searchproposed, no stack file
Open source
Not yet bound (pgvector is the natural fit)decided, not built
Start with pgvector in the database you already run: one store, one backup. Use Vector Search when the corpus already lives in Delta.
State and long-running workStateConversation, checkpoints, idempotency records, case records.Cloud service
Azure Database for PostgreSQLdecided, not built
Cloud service
Delta tables in Unity Catalog (Lakebase when row updates must be fast)built and run
Cloud service
RDS for PostgreSQLdecided, not built
Cloud service
Cloud SQL or AlloyDB for PostgreSQLproposed, no stack file
Open source
PostgreSQLbuilt and run
Managed PostgreSQL of your cloud: the same engine on every stack, so the code does not change. On Databricks, Delta.
WorkflowDurable steps and waits that survive a restart.Open source
DBOS, a library on the same PostgreSQLdecided, not built
Cloud service
Lakeflow Jobsdecided, not built
Open source
DBOS on the same RDSdecided, not built
Open source
DBOS on Cloud SQL (Cloud Workflows is the managed alternative)proposed, no stack file
Open source
Temporalbuilt and run
DBOS by default: no new infrastructure. Temporal when undo flows grow. Lakeflow Jobs on Databricks, where a wait is a run that ends and a new run that starts on the decision.
ApprovalWhere an irreversible action waits for a person.Open source
DBOS workflowsdecided, not built
Cloud service
A Databricks App writing the decision to a Delta tabledecided, not built
Open source
DBOS workflowsdecided, not built
Open source
DBOS workflowsproposed, no stack file
Open source
Temporal updatesbuilt and run
Follow the workflow choice. The decision is a message that your own rule validates, never a button the model can press.
TriggerWhat starts a run nobody is watching, once.Built by us
Requests storedecided, not built
Built by us
Requests storedecided, not built
Built by us
Requests storedecided, not built
Built by us
Requests storeproposed, no stack file
Built by us
Requests storebuilt and run
Build it. Exactly-once starts are a rule about your request ids.
ChannelThe chat surface and the desk where a person takes over.Open source
Chatwoot agent botdecided, not built
Open source
Chatwoot agent botdecided, not built
Open source
Chatwoot agent botdecided, not built
Open source
Chatwoot agent botproposed, no stack file
Open source
Chatwoot agent botbuilt and run
Open source, same everywhere. Skip it if the agent is a job with no chat.
Trust and policyIdentityWho the unit of work acts for, carried to every tool.Cloud service
Entra ID (External ID for customers)decided, not built
Cloud service
Unity Catalog service principal; reviewer sign-in from the workspacedecided, not built
Cloud service
Cognitodecided, not built
Cloud service
Cloud IAM with Identity Platformproposed, no stack file
Open source
Keycloakbuilt and run
Your cloud's identity service. Keycloak only where there is no cloud identity to lean on.
SecretsA credential reference that becomes a secret only at the moment of use.Cloud service
Key Vaultdecided, not built
Cloud service
Secret scopesdecided, not built
Cloud service
Secrets Managerdecided, not built
Cloud service
Secret Managerproposed, no stack file
Built by us
Environment settingsbuilt and run
Your cloud's secret store. Environment settings are acceptable for a laptop only.
PolicyRules checked at declared points: before the model, after it, before a tool.Built by us
Positioned rule listsdecided, not built
Built by us
Positioned rule listsdecided, not built
Built by us
Positioned rule listsdecided, not built
Built by us
Positioned rule listsproposed, no stack file
Built by us
Positioned rule listsbuilt and run
Build it. No guardrail product knows that a draft's number must equal a tool's number. Cloud filters sit in front as a second layer.
Observe, record and proveTelemetryOne span per call and one identifier for the whole task.Cloud service
Application Insights through OpenTelemetrydecided, not built
Cloud service
MLflow tracingdecided, not built
Cloud service
OpenTelemetry to CloudWatchdecided, not built
Cloud service
OpenTelemetry to Cloud Trace and Loggingproposed, no stack file
Open source
OpenTelemetry to Langfusebuilt and run
Emit OpenTelemetry everywhere; take the cloud's backend. Langfuse is a good choice off-cloud.
RecorderCapture a real interaction and replay it without a network.Built by us
JSON cassettesdecided, not built
Built by us
JSON cassettesdecided, not built
Built by us
JSON cassettesdecided, not built
Built by us
JSON cassettesproposed, no stack file
Built by us
JSON cassettes (VCR library is the target)built and run
Build it small; swap to a recording library when it earns its place.
Evaluation entry pointA callable the evaluations drive, with graders injected.Open source
AgentTwindecided, not built
Open source
AgentTwinbuilt and run
Open source
AgentTwindecided, not built
Open source
AgentTwinproposed, no stack file
Open source
AgentTwinbuilt and run
AgentTwin on every stack: scenarios are written once, against a declared world.
Release and configurationConfigurationModel pins, flags, thresholds, allow-lists, outside the image.Cloud service
App Configurationdecided, not built
Cloud service
Bundle variables and job parametersdecided, not built
Cloud service
AppConfigdecided, not built
Cloud service
A managed config service, or settings in Gitproposed, no stack file
Open source
Typed settings (OpenFeature is the target)built and run
Your cloud's config service. Keep the numbers in the specification and read them, never restate them.
Agent registryThe catalogue of agents and tools that may run.Cloud service
API Centerdecided, not built
Cloud service
Unity Catalog models and functionsdecided, not built
Cloud service
Agent Registry (not offered in every region; a catalogue in Git works)decided, not built
Cloud service
Artifact Registry plus a catalogue in Gitproposed, no stack file
Open source
A catalogue in Gitbuilt and run
A catalogue in Git is enough to start. Use the platform registry when it gives you permissions you would otherwise build.

The same map, cut three ways

The first table says which product fills each concern. This one asks a different question for each platform: for every concern, how much does the platform hand you, how much comes from assets we already share across all our agents, and what is left that every single agent must write for itself.

X · The platformWhat the cloud or data platform gives out of the box. Different on every stack.
Y · Shared assetsThe harness library, its adapters, AgentTwin, the evaluation library, the catalogues. Written once, reused by every agent. Where a platform has no adapter yet, that is the work of the stack, not of any agent.
Z · Each agentIts specification, tools, rules, world, scenarios and thresholds. The same on every platform, and the only part that is yours.

Boxes show who carries the concern: platform, shared assets, agent. A darker first box means the platform carries more.

Azure

ConcernWho carries itX · The platform gives out of the boxY · Shared assets we reuseZ · Each agent writes
Control loopplatform nothing for thisNothing: it hosts the containerThe loop: step and cost budgets, repeat detection, typed endingsshared asset is the whole answerIts budget numbers from the specification, its standing instruction, and what each ending does next
Hostingplatform carries most of itContainer Apps with revisions for canary releasesA service entry point and settings loaderadapter ready: container buildIts container or job definition and its environment settings
Model accessplatform carries most of itAPI Management as gateway; Azure's model serviceA model port with an OpenAI-compatible client, retries, a breaker and an approved-model listadapter ready: OpenAI-compatible clientWhich models are approved, their prices, and sampling settings
Toolsplatform nothing for thisNothing specific; you host MCP serversA tool client over MCP: result size limits, side-effect classes, idempotency keys, identity on every calladapter ready: MCP clientIts own tools: names, input and output shapes, which are read or irreversible, who may call each
Knowledge retrievalplatform carries part of itAI Search exists; not chosen, pgvector isA retrieval port: the caller's rights applied before ranking, a source on every passageadapter ready: pgvectorIts corpus, how it is cut into passages, how sources are linked
State and recordsplatform carries most of itAzure Database for PostgreSQLState stores: checkpoints, idempotency records, facts, conversationadapter ready: PostgreSQL storeIts own entities and their migrations (for example the drafts and decisions it keeps)
Long waits and approvalsplatform carries part of itDurable Functions and Logic Apps exist; not chosenApproval and escalation machinery: durable waits, expiry, a decision validated by a rule, a queue for a personadapter ready: DBOS workflowsWho may decide, how long a decision stays valid, and which conditions escalate (all from its specification)
Identity and accessplatform carries most of itEntra ID; managed identityAn identity carried into every tool call; the far end verifies itadapter ready: token exchangeIts scopes, and which rows each caller may see or change
Secretsplatform carries most of itKey VaultA secrets port: a reference becomes a secret only at the moment of useadapter still to write: Key Vault adapterNothing but the names of the secrets it needs
Policy and guardrailsplatform carries part of itContent Safety filters: genericRule positions (before the model, after it, before a tool), output rules, redactionshared asset is the whole answerIts own rules: what it refuses, which checks a draft must pass (for example a number must equal a tool's number)
Telemetryplatform carries most of itApplication InsightsOne span per call, one identifier per task, redaction before export, standard span namesadapter ready: Azure Monitor distroWhich domain facts it records, and the labels its dashboards need
Evaluationplatform carries part of itFoundry evaluations: model-levelAgentTwin (worlds, scenarios, simulated users), the evaluation library, the four gates, the cataloguesshared asset is the whole answerIts world, its scenarios, its labelled cases and its domain checks
Configuration and releaseplatform carries most of itApp ConfigurationA profile loader: decisions, thresholds and accepted gaps resolved from a stack fileadapter still to write: config adapterIts profile answers and its own thresholds; it never restates the specification's numbers
Costplatform carries part of itCost Management: by resource, not by taskA per-task meter, a price table, a ceiling that stops workshared asset is the whole answerIts ceiling per task and what counts as a successful task

Databricks

ConcernWho carries itX · The platform gives out of the boxY · Shared assets we reuseZ · Each agent writes
Control loopplatform carries part of itAgent Framework interface for logging and serving; the loop stays oursThe loop: step and cost budgets, repeat detection, typed endingsshared asset is the whole answerIts budget numbers from the specification, its standing instruction, and what each ending does next
Hostingplatform carries most of itLakeflow jobs; Databricks Apps for a deskA service entry point and settings loaderadapter still to write: job wrapperIts container or job definition and its environment settings
Model accessplatform carries most of itFoundation Model APIs; AI Gateway where a serving endpoint is allowedA model port with an OpenAI-compatible client, retries, a breaker and an approved-model listadapter ready: OpenAI-compatible client (used)Which models are approved, their prices, and sampling settings
Toolsplatform carries most of itUnity Catalog functions: typed, permissioned, auditedA tool client over MCP: result size limits, side-effect classes, idempotency keys, identity on every calladapter still to write: tool client over UC functionsIts own tools: names, input and output shapes, which are read or irreversible, who may call each
Knowledge retrievalplatform carries most of itVector Search, synced from DeltaA retrieval port: the caller's rights applied before ranking, a source on every passageadapter still to write: Vector Search adapterIts corpus, how it is cut into passages, how sources are linked
State and recordsplatform carries most of itDelta tables in Unity CatalogState stores: checkpoints, idempotency records, facts, conversationadapter still to write: Delta storeIts own entities and their migrations (for example the drafts and decisions it keeps)
Long waits and approvalsplatform carries part of itLakeflow Jobs run steps; a wait is a job that ends and restartsApproval and escalation machinery: durable waits, expiry, a decision validated by a rule, a queue for a personadapter still to write: job per decisionWho may decide, how long a decision stays valid, and which conditions escalate (all from its specification)
Identity and accessplatform carries most of itUnity Catalog service principal and workspace sign-inAn identity carried into every tool call; the far end verifies itadapter still to write: workspace identityIts scopes, and which rows each caller may see or change
Secretsplatform carries most of itSecret scopesA secrets port: a reference becomes a secret only at the moment of useadapter still to write: secret scope adapterNothing but the names of the secrets it needs
Policy and guardrailsplatform carries part of itAI Gateway safety and PII options: genericRule positions (before the model, after it, before a tool), output rules, redactionshared asset is the whole answerIts own rules: what it refuses, which checks a draft must pass (for example a number must equal a tool's number)
Telemetryplatform carries most of itMLflow tracingOne span per call, one identifier per task, redaction before export, standard span namesadapter still to write: MLflow exporterWhich domain facts it records, and the labels its dashboards need
Evaluationplatform carries part of itAgent Evaluation and MLflow evaluation: model-levelAgentTwin (worlds, scenarios, simulated users), the evaluation library, the four gates, the cataloguesshared asset is the whole answerIts world, its scenarios, its labelled cases and its domain checks
Configuration and releaseplatform carries most of itBundle variables and job parametersA profile loader: decisions, thresholds and accepted gaps resolved from a stack fileadapter still to write: bundle adapterIts profile answers and its own thresholds; it never restates the specification's numbers
Costplatform carries part of itBilling system tables: by resource, not by taskA per-task meter, a price table, a ceiling that stops workshared asset is the whole answerIts ceiling per task and what counts as a successful task

AWS

ConcernWho carries itX · The platform gives out of the boxY · Shared assets we reuseZ · Each agent writes
Control loopplatform carries part of itAgentCore Runtime and Bedrock Agents exist; deliberately not used for the loopThe loop: step and cost budgets, repeat detection, typed endingsshared asset is the whole answerIts budget numbers from the specification, its standing instruction, and what each ending does next
Hostingplatform carries most of itECS on FargateA service entry point and settings loaderadapter ready: container buildIts container or job definition and its environment settings
Model accessplatform carries most of itBedrock; AgentCore GatewayA model port with an OpenAI-compatible client, retries, a breaker and an approved-model listadapter ready: OpenAI-compatible clientWhich models are approved, their prices, and sampling settings
Toolsplatform carries part of itAgentCore Gateway turns APIs into toolsA tool client over MCP: result size limits, side-effect classes, idempotency keys, identity on every calladapter ready: MCP clientIts own tools: names, input and output shapes, which are read or irreversible, who may call each
Knowledge retrievalplatform carries part of itKnowledge Bases exist; not chosen, pgvector isA retrieval port: the caller's rights applied before ranking, a source on every passageadapter ready: pgvectorIts corpus, how it is cut into passages, how sources are linked
State and recordsplatform carries most of itRDS for PostgreSQLState stores: checkpoints, idempotency records, facts, conversationadapter ready: PostgreSQL storeIts own entities and their migrations (for example the drafts and decisions it keeps)
Long waits and approvalsplatform carries part of itStep Functions exist; not chosenApproval and escalation machinery: durable waits, expiry, a decision validated by a rule, a queue for a personadapter ready: DBOS workflowsWho may decide, how long a decision stays valid, and which conditions escalate (all from its specification)
Identity and accessplatform carries most of itCognito and IAMAn identity carried into every tool call; the far end verifies itadapter ready: signing helpersIts scopes, and which rows each caller may see or change
Secretsplatform carries most of itSecrets Manager and Parameter StoreA secrets port: a reference becomes a secret only at the moment of useadapter ready: AWS adapterNothing but the names of the secrets it needs
Policy and guardrailsplatform carries part of itBedrock Guardrails: genericRule positions (before the model, after it, before a tool), output rules, redactionshared asset is the whole answerIts own rules: what it refuses, which checks a draft must pass (for example a number must equal a tool's number)
Telemetryplatform carries most of itCloudWatch; X-RayOne span per call, one identifier per task, redaction before export, standard span namesadapter ready: OpenTelemetry exportWhich domain facts it records, and the labels its dashboards need
Evaluationplatform carries part of itBedrock evaluations: model-levelAgentTwin (worlds, scenarios, simulated users), the evaluation library, the four gates, the cataloguesshared asset is the whole answerIts world, its scenarios, its labelled cases and its domain checks
Configuration and releaseplatform carries most of itAppConfigA profile loader: decisions, thresholds and accepted gaps resolved from a stack fileadapter ready: AWS adapterIts profile answers and its own thresholds; it never restates the specification's numbers
Costplatform carries part of itCost Explorer: by resource, not by taskA per-task meter, a price table, a ceiling that stops workshared asset is the whole answerIts ceiling per task and what counts as a successful task

GCP (proposed)

ConcernWho carries itX · The platform gives out of the boxY · Shared assets we reuseZ · Each agent writes
Control loopplatform carries part of itAgent runtimes exist (ADK, Agent Engine); would not own the loopThe loop: step and cost budgets, repeat detection, typed endingsshared asset is the whole answerIts budget numbers from the specification, its standing instruction, and what each ending does next
Hostingplatform carries most of itCloud RunA service entry point and settings loaderadapter ready: container buildIts container or job definition and its environment settings
Model accessplatform carries most of itVertex AI model catalogue; Apigee as gatewayA model port with an OpenAI-compatible client, retries, a breaker and an approved-model listadapter still to write: check Vertex's compatible endpointWhich models are approved, their prices, and sampling settings
Toolsplatform nothing for thisNothing specific; you host MCP serversA tool client over MCP: result size limits, side-effect classes, idempotency keys, identity on every calladapter ready: MCP clientIts own tools: names, input and output shapes, which are read or irreversible, who may call each
Knowledge retrievalplatform carries part of itVertex AI Vector Search and Search existA retrieval port: the caller's rights applied before ranking, a source on every passageadapter ready: pgvector on Cloud SQLIts corpus, how it is cut into passages, how sources are linked
State and recordsplatform carries most of itCloud SQL or AlloyDB for PostgreSQLState stores: checkpoints, idempotency records, facts, conversationadapter ready: PostgreSQL storeIts own entities and their migrations (for example the drafts and decisions it keeps)
Long waits and approvalsplatform carries part of itCloud Workflows existsApproval and escalation machinery: durable waits, expiry, a decision validated by a rule, a queue for a personadapter ready: DBOS on Cloud SQLWho may decide, how long a decision stays valid, and which conditions escalate (all from its specification)
Identity and accessplatform carries most of itCloud IAM; Identity PlatformAn identity carried into every tool call; the far end verifies itadapter still to write: Google identityIts scopes, and which rows each caller may see or change
Secretsplatform carries most of itSecret ManagerA secrets port: a reference becomes a secret only at the moment of useadapter still to write: Secret Manager adapterNothing but the names of the secrets it needs
Policy and guardrailsplatform carries part of itVertex safety filters and Model Armor: genericRule positions (before the model, after it, before a tool), output rules, redactionshared asset is the whole answerIts own rules: what it refuses, which checks a draft must pass (for example a number must equal a tool's number)
Telemetryplatform carries most of itCloud Trace and LoggingOne span per call, one identifier per task, redaction before export, standard span namesadapter ready: OpenTelemetry exportWhich domain facts it records, and the labels its dashboards need
Evaluationplatform carries part of itGen AI evaluation service: model-levelAgentTwin (worlds, scenarios, simulated users), the evaluation library, the four gates, the cataloguesshared asset is the whole answerIts world, its scenarios, its labelled cases and its domain checks
Configuration and releaseplatform carries part of itA managed config service or GitA profile loader: decisions, thresholds and accepted gaps resolved from a stack fileadapter still to write: config adapterIts profile answers and its own thresholds; it never restates the specification's numbers
Costplatform carries part of itBilling export: by resource, not by taskA per-task meter, a price table, a ceiling that stops workshared asset is the whole answerIts ceiling per task and what counts as a successful task

Open stack

ConcernWho carries itX · The platform gives out of the boxY · Shared assets we reuseZ · Each agent writes
Control loopplatform nothing for thisNothingThe loop: step and cost budgets, repeat detection, typed endingsshared asset is the whole answerIts budget numbers from the specification, its standing instruction, and what each ending does next
Hostingplatform carries part of itYou run the containersA service entry point and settings loaderadapter ready: compose fileIts container or job definition and its environment settings
Model accessplatform nothing for thisNothing; LiteLLM is the open-source gateway you runA model port with an OpenAI-compatible client, retries, a breaker and an approved-model listadapter ready: OpenAI-compatible clientWhich models are approved, their prices, and sampling settings
Toolsplatform nothing for thisNothingA tool client over MCP: result size limits, side-effect classes, idempotency keys, identity on every calladapter ready: MCP clientIts own tools: names, input and output shapes, which are read or irreversible, who may call each
Knowledge retrievalplatform nothing for thisNothingA retrieval port: the caller's rights applied before ranking, a source on every passageadapter ready: pgvectorIts corpus, how it is cut into passages, how sources are linked
State and recordsplatform carries part of itYou run PostgreSQLState stores: checkpoints, idempotency records, facts, conversationadapter ready: PostgreSQL storeIts own entities and their migrations (for example the drafts and decisions it keeps)
Long waits and approvalsplatform nothing for thisNothing; Temporal is the open-source choiceApproval and escalation machinery: durable waits, expiry, a decision validated by a rule, a queue for a personadapter ready: TemporalWho may decide, how long a decision stays valid, and which conditions escalate (all from its specification)
Identity and accessplatform nothing for thisNothing; Keycloak is the open-source choiceAn identity carried into every tool call; the far end verifies itadapter ready: token checkIts scopes, and which rows each caller may see or change
Secretsplatform nothing for thisNothingA secrets port: a reference becomes a secret only at the moment of useadapter ready: environment settingsNothing but the names of the secrets it needs
Policy and guardrailsplatform nothing for thisNothingRule positions (before the model, after it, before a tool), output rules, redactionshared asset is the whole answerIts own rules: what it refuses, which checks a draft must pass (for example a number must equal a tool's number)
Telemetryplatform carries part of itYou run Langfuse or a collectorOne span per call, one identifier per task, redaction before export, standard span namesadapter ready: OpenTelemetry exportWhich domain facts it records, and the labels its dashboards need
Evaluationplatform nothing for thisNothingAgentTwin (worlds, scenarios, simulated users), the evaluation library, the four gates, the cataloguesshared asset is the whole answerIts world, its scenarios, its labelled cases and its domain checks
Configuration and releaseplatform nothing for thisNothingA profile loader: decisions, thresholds and accepted gaps resolved from a stack fileadapter ready: typed settingsIts profile answers and its own thresholds; it never restates the specification's numbers
Costplatform nothing for thisNothingA per-task meter, a price table, a ceiling that stops workshared asset is the whole answerIts ceiling per task and what counts as a successful task

The count, per platform

PlatformConcerns the platform mostly carries (of 14)Concerns it gives nothing forAdapters ready in the shared libraryAdapters still to write
Azure7282
Databricks9019
AWS70100
GCP (proposed)6164
Open stack011100
What this shows. Z does not change with the platform. Y shrinks or grows with the stack: Azure, AWS and the open stack have most adapters; Databricks and GCP need the library to grow before an agent can run there on platform services. X is where platforms differ most, and it is the column to read when choosing, but a platform that carries a concern does not remove the need for the agent to write its own rules and checks.

The levels in this view are our reading of each platform, not a measurement. The adapter status comes from the shared library as of 20 November 2026; GCP and Databricks adapters do not exist yet. Platform product lists change quickly.

How to decide, in three rules

1 · Build the middleThe loop, limits, cost meter, policy rules and start-once triggers are the same few lines on every stack. Writing them is cheaper than adapting a product, and they must see your task.
2 · Lean on the cloud you are onFor hosting, identity, secrets, telemetry and configuration, take the platform's own service. It is already approved, billed and audited there.
3 · Keep one open default for the restPostgreSQL, a library for durable waits, MCP for tools, OpenTelemetry for records. They run on any cloud, so moving stacks is a change of adapter, not of code.
Why this works. Every product sits behind a port: a small interface the harness owns. A stack is a file that says which product fills each port. Changing cloud means changing that file and writing one adapter per changed port. The agent, its specification and its tests stay put.

What to check before relying on this

Where to go next