For Azure users

You know Azure. This page translates its vocabulary into Crusoe Agent Platform terms, tells you what will feel familiar, is honest about what Azure has that we don't, and points you at the exact docs pages to migrate each workload.

The shortest summary: most of what Azure asks you to decide up front — a hosting plan, a pricing tier, a storage backend, a subnet size, Basic versus Standard setup — is not a decision here, because there is only one option.

Terminology map

In Azure	Here	Notes
Entra ID tenant	Organization	Orgs own projects and users. Only platform admins create them.
Subscription and resource group	Project	One thing, not two. A project is your isolated workspace: its own resources, quota, members, and audit log. There is no separate billing boundary to nest inside.
Subscription ID and resource group name	Project slug and short	The slug is the readable name (ml-team). The short is a small immutable id that appears in namespaces and hostnames and survives a rename.
Entra RBAC role assignment (Contributor, Reader, Session Executor)	Project role: member or admin	Two roles per project, no role catalog and no custom role definitions. A member uses the project's resources; an admin also does the irreversible things.
Management-plane vs data-plane permissions	Two authority axes	Same instinct, made explicit: metadata authority (rename, delete, manage members) is separate from resource authority (agents, secrets, topics, indexes). A platform admin has metadata authority everywhere and resource authority nowhere. See security overview.
Azure portal	Web console at https://console.codyhill.dev	The public front door. Sign-in is email and password; an admin creates your account or sends an invitation link — there is no sign-up page. See create an account.
Azure CLI (az) and azd	platformctl	One binary, no extensions to install or version-pin. See install the CLI.
Managed identity or service principal	Service account (name@<project-short>.cai.local)	A machine identity that belongs to one project and holds a role like a person does. It can never manage members or mint credentials.
Client secret or certificate	API key (cai_<keyid>_<secret>)	Shown exactly once at creation, revocable instantly, with an optional expiry. See service accounts and API keys.
Entra token acquisition before an API call	Authorization: Bearer with your key	One header. No token endpoint, no scope string, no MSAL library. See API authentication.
Container Apps environment	Nothing — the project is the boundary	There is no environment resource to create before your first deploy.
Container app	Serverless service	Container in, scale-to-zero HTTPS endpoint out.
Container Apps revision	Revision	Same word, same meaning: each deploy creates a new immutable revision, and traffic can be split between them. See traffic and revisions.
Container Apps scale rules (KEDA) and min replicas	Autoscaling and min instances	Same scale-to-zero behavior, fewer knobs. See autoscaling and scale to zero.
Ingress FQDN (*.azurecontainerapps.io)	https://<name>-<project-short>.apps.codyhill.dev	Every workload gets a public address on deploy.
VNet integration and subnet delegation to Microsoft.App/environments	Not applicable	There is no delegated subnet to size, no /27 minimum, and no FQDN allowlist to configure. Workloads are isolated by the project's network policy.
Azure Functions	Function	One file exposing handle(event). Runtimes: Python, Node.js, Go, Ruby.
Hosting plan (Consumption, Flex Consumption, Premium, Dedicated)	No plan to choose	There is one way to run a function. Nothing to pick before your first deploy, and nothing to migrate between later.
Azure Functions trigger and binding catalog	handle(event) plus Pub/Sub	One event shape instead of a bindings reference to memorize. Honest gap: the catalog of things that can trigger a function is much smaller. See HTTP and events.
Foundry Agent Service Hosted agent (your container, your framework)	Agent Engine	Upload agent code, get a scale-to-zero chat endpoint. ADK, LangGraph, and CrewAI all run unmodified.
Foundry Prompt agent (no-code, portal-authored)	No equivalent	This platform is code-first only. There is no portal-authored agent type, and we would rather say that than stretch a mapping.
Foundry thread	session_id	A conversation's identity. See sessions.
Foundry run	One /invoke call	A single agent turn. See invoke.
Foundry Responses API	The agent's own invoke endpoint	Called through the platform API or platformctl invoke.
Foundry Basic vs Standard setup (Microsoft-managed vs your own storage)	Not a choice	There is one storage path. You never have to discover in an FAQ that a compliance-relevant fork existed.
Foundry capability host (bring your own Storage, Cosmos DB, AI Search)	Not applicable	There is no managed-versus-your-own fork to configure.
Container Apps dynamic sessions (session pool + caller-supplied identifier)	Code Sandbox	One HTTP call runs your code in a pod that is used once and destroyed. There is no pool resource to provision, no identifier to manage, and no session to stop.
Azure AI Search vector store and vectorSearch profile	VectorDB collection	A dedicated vector database, not a vector field inside a search engine. HNSW defaults are chosen for you — there is no profile to author.
AI Search Search Units (replicas x partitions)	No capacity math	You do not plan replicas and partitions before launch.
AI Search filters and $filter expressions	Payload filters	Ordinary JSON match and range conditions on a point's payload. See search.
Azure Managed Redis (and the retiring Azure Cache for Redis)	MemoryStore	Speaks the Redis and Valkey protocol, so your existing clients and redis-cli work unchanged. One product, one generation, no migration path to plan.
Cache pricing tier (Basic, Standard, Premium, Enterprise)	No tier	Nothing to choose before you write your first key.
Service Bus queue	Pub/Sub topic with one subscription	Point-to-point work distribution.
Service Bus topic and subscriptions	Pub/Sub topic and subscriptions	Same two nouns. Each subscription gets its own delivery cursor.
Event Grid	Pub/Sub	The same one service. There is no separate lightweight event router to choose between.
Event Hubs	No equivalent	There is no high-throughput streaming-ingestion product with consumer groups and replay.
Service Bus sessions, transactions, scheduled messages	No equivalent	Honest gap: the enterprise messaging features are not here. See topics and subscriptions for what is.
Durable Functions orchestrator function	Durable workflow	The same "coordinates other functions" role, written as ordinary code.
Durable Functions activity function	Activity	Direct analogue: one unit of work, with retries and timeouts set by policy.
Durable Functions durable timer	Workflow sleep	Durable across restarts, same guarantee.
Durable Task Scheduler / storage-provider choice (Azure Storage, Netherite, MSSQL)	Nothing to choose	The workflow engine's backing store is already provisioned. You never pick one before "hello world".
Key Vault (the vault resource)	Nothing — secrets are project-scoped	There is no vault object to create first. See secrets manager.
Key Vault secret and versions	Secret and versions	Numbered versions; writing again creates the next one.
Key Vault soft-delete and purge protection	No equivalent	Deleting a secret destroys every version immediately and is not recoverable. We say so at the point of deletion.
Key Vault keys, certificates, and Managed HSM	No equivalent	Secrets only — opaque values, not a key-management service.
Azure Monitor, Log Analytics, and KQL	Logs	Live tail plus persisted history that survives scale-to-zero. Default retention is 14 days, with no query language, no workbooks, and no alert rules.
Activity Log	Per-project audit log	On by default, readable by every project member, nothing to configure. It also records any provider break-glass access.
Subscription quotas	Project quotas	A live view of instances, services, CPU, and memory against your project's caps.
Publish an agent to Microsoft 365 Copilot	Embed chat	Different destination, same goal: give people a chat surface for your agent. One rotatable public key plus an origin allowlist puts a widget on any website.
No managed equivalent	MCP Servers	Publish Python tools as a hosted Model Context Protocol endpoint, with immutable versions and one-command rollback.

What will feel familiar

• "Revision" means what you think it means. Deploying creates a new immutable revision, and traffic can be split between them. Container Apps muscle memory transfers directly.
• Scale to zero. Idle workloads stop and the next request wakes them — the same behavior KEDA gives a container app, applied to agents and functions too.
• A thread is a session. If you have written against Foundry threads and runs, our sessions and invoke pages will read like a rename.
• Orchestrator and activity. The Durable Functions mental model carries over almost word for word — with the replay rules documented up front instead of discovered in a debugger.
• A machine identity holding a role. A service account is the managed-identity idea: it belongs to one project, holds a role, and its key is a credential you create and revoke.
• Bring your own container. Hosted agents made you the owner of your agent's code. So does this platform — there is no other option.

What is different

Simpler here

• No decisions before "hello world". Azure asks you to pick a Functions hosting plan, a Service Bus pricing tier, a Durable Functions storage provider, and Foundry's Basic-versus-Standard setup before your first success. None of those choices exist here.
• One documented path, not five. Foundry's hosted-agent quickstart forks into five parallel workflows (azd, Python SDK, VS Code, Copilot Canvas, and an agentic skill) on a single page. Our agent quickstart has one path, and the alternatives live on their own pages.
• No networking prerequisites. No subnet delegation, no /27 minimum subnet, no FQDN allowlist to arrange before a VNet deploy fails.
• No token dance before the first call. Azure's dynamic-sessions examples need an Entra token, a subscription id, a resource group, and a session-pool name filled in before anything runs. Ours needs one bearer header.
• One messaging service. Service Bus, Event Grid, and Event Hubs solve overlapping problems well enough that Microsoft publishes a page to help you choose. There is nothing to choose here.
• One product generation. Azure Cache for Redis is retiring in favor of Azure Managed Redis, and its docs now open with a retirement banner. We promise the opposite: if we ever rename anything, the old identifier keeps working and the docs will say so.
• Sandbox isolation is not optional. Dynamic sessions let a session persist and be reused across calls. Here, every execution gets a fresh pod that is destroyed afterward — there is no reuse mode to accidentally leave on. See security and limits.
• Provider access is structural, not contractual. A platform admin gets 404 not found on your agents and secrets. The only way in is a break-glass grant that expires, appears on your members list, and lands in your audit log. See break-glass and audit.

Azure has more

Be honest with yourself about these before you migrate. If any is a hard requirement today, Azure is the right choice, and we would rather say so here than have you find out later.

• Regions and availability zones. Azure runs dozens of regions with zonal redundancy. The platform runs in one place. There is no region picker.
• SLAs and compliance. No uptime SLA, no customer-managed keys, no data-residency commitments, and no compliance attestations.
• Marketplace and catalog breadth. Azure Marketplace and hundreds of adjacent services have no counterpart. We have the services in the table above, and that is all.
• Identity maturity. Entra ID gives you SSO, MFA, conditional access, and managed identities that carry no secret at all. Here: email and password, 12-hour sign-in tokens that cannot be revoked early, and no federation.
• Model catalog and a no-code agent type. Foundry's model catalog is large, and its Prompt agents let non-developers ship an agent from the portal. Agents here talk to a single OpenAI-compatible Crusoe Managed Inference endpoint and always come from code.
• Guardrails and responsible-AI tooling. Azure's content-safety and responsible-AI layer has no equivalent here yet.
• Enterprise messaging features. Service Bus sessions (FIFO per key), transactions, scheduled messages, and dead-lettering; Event Grid's push filtering; Event Hubs' streaming replay.
• Search depth. Azure AI Search offers hybrid and semantic ranking on top of vectors. Ours is straightforward vector similarity with payload filters.
• Key management. Key Vault stores keys and certificates, offers HSM backing, and protects deletes with soft-delete and purge protection. We store opaque secret values only, and delete means delete.
• Stronger sandbox isolation and longer runs. Dynamic sessions use Hyper-V isolation, allow roughly 220 seconds per execution, and support file upload and download. Our sandbox pods use ordinary container isolation (runc) by default, and a snippet run is capped at 20 seconds by default and 60 seconds at most.
• Observability. Log Analytics, KQL, workbooks, and alert rules beat 14 days of plain log history and live-only counts.
• GPU instance classes. Azure lets you pick specific accelerator types. There is no GPU instance-class selection here today.
• A public API hostname. There is no public API endpoint yet. The console is the front door; automation reaches the API through the $CAI_API address your administrator provides, often a port-forward.

Try the Key Vault muscle memory

On Azure, storing a secret starts with creating a vault. Here there is no vault — a secret belongs to the project directly. With a bearer token and your project id:

export CAI_API="http://localhost:8081"   # your API endpoint (from your admin, or a port-forward)
export TOKEN="$CAI_TOKEN"                # a session token or API key
export PROJECT="your-project-id"

curl -s -X POST "$CAI_API/v1/projects/$PROJECT/secrets" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"name":"openai-api-key","value":"sk-live-abc123"}'

You should see (status 201):

{"name":"openai-api-key","version":1,"created":true,"note":"the value is stored. Nothing - this API included - will show it back to you except an explicit, audited reveal."}

Writing the same name again creates version 2 — that is the whole rotation story, exactly as in Key Vault. What Key Vault has and we do not: soft-delete, purge protection, and keys or certificates. Full walkthrough: manage secrets.

Migration pointers

Moving this from Azure	Start here
A container app	Serverless overview, then autoscaling and scale to zero
An Azure Function	Functions quickstart, then runtimes
A Foundry hosted agent	Agent quickstart, then deploy and tools
Threads and runs in your app code	Sessions and invoke
An AI Search vector index	VectorDB quickstart, then search and the RAG chatbot tutorial
An Azure Managed Redis or Azure Cache for Redis instance	MemoryStore quickstart
Service Bus queues or Event Grid topics	Pub/Sub quickstart, then publish and consume
A Durable Functions orchestration	Run a workflow and the durable agent pipeline tutorial
Dynamic sessions code execution	Run code, then security and limits
Key Vault secrets	Manage secrets, then use in workloads
Entra role assignments, managed identities, and CI credentials	Projects and access and the CI/CD service account tutorial

Next steps

• Service mapping — every service side by side across all three clouds.
• For AWS users and for Google Cloud users — the other two translation guides.
• Core concepts — the platform's own vocabulary, from scratch.