I’ve spent now a good amount of time around Azure’s development tooling, and therefore have some opinions about the whole developer experience of deploying AI agents on Azure AI Foundry.

Azure provides the Azure Developer CLI (azd), and according to Microsoft it should accelerate your path from a local development environment to Azure.

But just from reading its docs and example templates - azure.yaml, Bicep files, hook scripts - I didn’t get the sense that azd was the right tool for starting an agentic AI project. It seemed to bundle agents into the same deployment lifecycle as the long-lived cloud infrastructure around them (networking, access control, etc.).

So I decided to dig deeper and benchmark it: using azd to deploy against Azure AI Foundry, starting from just a Foundry account and a project. How long until a deployed model and its agent can actually answer an inference request?

Across 5 runs, azd averaged 22.5s for a GPT-5.6 deployment plus a simple prompt agent. Curious where that time actually went, I dug through azd’s debug log, tracing the calls with Claude’s help.

Where the 22.5s goes

Before azd touches the network at all, it shells out to a separate Bicep compiler three times to turn the template into something Azure Resource Manager (ARM) can read. For those unfamiliar with Azure, ARM is the API layer that Azure deployments ultimately go through. Whether you deploy with the Azure Portal, az, Bicep, Terraform, or azd, those tools eventually translate your intent into requests to Azure’s resource management APIs.

Going back to my experiment, just compiling the Bicep templates takes about 9 seconds on my laptop, and this is before a single request leaves the machine.

And after this, it has to deal with the fact that ARM also tracks the deployment itself. azd validates that deployment, submits it, and polls its status until ARM says it has succeeded. In my trace, that meant roughly half a dozen additional round-trips before the resource I actually asked for was even confirmed. Call it another 5 seconds spent watching the deployment wrapper rather than the thing being deployed.

The last chunk is different. Not everything in an agent stack can be provisioned through the ARM template, and creating the agent itself requires going through the Foundry APIs. So azd hands off to a hook script, which spins up an entire Python interpreter just to make one API call.

Why azd does this

I’ve worked as a platform engineer, and I get why this exists when the job is managing real infrastructure. Bicep compilation, the ARM wrapper, and deployment state tracking buy real things in production: declarative and idempotent deployments, dependency ordering, validation, and a consistent audit trail for infrastructure where everything depends on everything else: networking, IAM, and dozens of resource types.

None of that buys me anything when I just want to get a model and a prompt agent live. I don’t think azd is bad tooling. I think it’s built for a different job than the one I’m doing.

Agent definitions sit much closer to business logic than infrastructure, and they change on a completely different cadence. I don’t think updating a prompt, changing a tool, or tweaking an agent definition should have to pass through the same pipeline as long-lived cloud infrastructure. When I’m iterating on an agent, I might make those changes several times an hour, not once a quarter.

So the Azure-specific benchmark results aren’t really the point here. They’re just a concrete example of a broader mismatch in managed cloud tooling.

Now if you come from a Kubernetes background, your first reaction may be that the agent shouldn’t be a cloud resource at all. That’s a perfectly reasonable architecture: keep prompts, tools, and orchestration in application code and let the platform provide models and runtime primitives underneath. This problem only appears once agent definitions themselves are platform-managed objects.

But in a large enterprise, that’s less and less the developer’s call. Once an agent needs its own identity, scoped permissions, and an audit trail, and the organization wants an inventory of which agents exist and what they’re allowed to reach, the definition will end up in the control plane whether or not you’d have put it there to begin with.

(If you’re wondering why the model deployment is part of the experiment at all, rather than just the agent, I get into that in the appendix.)

The trade-off isn’t mandatory

What IaC is supposed to buy you (repeatability, idempotency, change detection, an audit trail) doesn’t inherently require a Terraform-style state file or ARM’s tracked deployment wrapper. Those are ways of implementing those guarantees, not the guarantees themselves. A tool can derive current state from the platform APIs, rely on idempotent resource operations, and keep history elsewhere. ARM’s choice to wrap every deployment in a tracked resource is reasonable for the infrastructure workloads it was designed for, but it isn’t the only possible design.

In practice, the tooling is already starting to reflect that distinction. Microsoft’s own GitOps reference architecture for Foundry Hosted Agents separates /infra from /src/prompts, /src/agents and /src/tools. Long-lived infrastructure is provisioned with Bicep, while prompts and agent code are versioned, reviewed, packaged, and promoted on their own lifecycle. A prompt change doesn’t require another infrastructure deployment.

AWS approaches the same need from a different direction. Bedrock AgentCore supports direct ZIP deployment, giving agent developers a much tighter iteration loop than a traditional CDK or CloudFormation pipeline. I don’t think throwing a ZIP at an API is a particularly satisfying end state either: it gives up some of the declarative structure, constraints, and repeatability that make infrastructure tooling valuable in the first place. But it does recognize the underlying need. Agent developers need tooling designed around rapid behavioral iteration, not just infrastructure provisioning.

That’s the gap I think the current tooling still hasn’t filled. Agent definitions should be versioned, reviewable, reproducible, and safely promoted between environments, without forcing every prompt or tool change through a process designed for traditional cloud infrastructure.

fas: split by change frequency, not by resource type

With that problem in mind I wanted to see what a deployment path designed around a tighter iteration loop could actually look like.

I built fas-cli (foundry agents stack) as a tooling experiment. Models, connections, toolboxes, and agent definitions change frequently, so fas skips Bicep for that layer and deploys directly through the Azure SDK. On every fas plan, it reads the current resources from Azure and diffs them against the desired state expressed in Python.

For the small stack I benchmarked—a model deployment plus a running prompt agent—that cuts deployment time from an average of 22.5 seconds with azd to about 10 seconds with fas.

azd / Bicepfas
Deploy time (model + prompt agent)22.5s avg (5 runs)10s avg (5 runs)
StateAzure is the source of truth; ARM retains deployment historyAzure is the source of truth; no separate deployment state
PlanningARM/Bicep evaluates desired state against live AzureDiffs Python definitions against live Azure
Dependency executionARM dependency graph, with additional azd orchestrationDAG from typed references, independent operations run concurrently
Concurrency controlARM deployment semanticsOptimistic, no global lock (see below)
ScopeAny Azure resourceFoundry accounts/projects only

Three things make the iteration loop lighter.

  1. No separate state store. fas plan reads Azure directly and compares what exists with the Python definitions. There is no Terraform-style state file, and no fas deployment record that has to be kept in sync with reality.

    That doesn’t mean there is no state: Azure itself is the state.

    The trade-off is that fas doesn’t maintain its own historical snapshot of what it previously deployed. If a change is wrong, you fix the definition and deploy again, or revert the change in Git. Azure’s current state, Azure’s platform logs, and Git history are the records.

  2. No deployment wrapper. fas calls the relevant Foundry APIs directly and waits on those operations. There is no separate ARM deployment resource to validate, submit, and poll first.

    That shortcut only works because of the deliberately narrow scope for the tooling. ARM has to orchestrate almost anything Azure can provision; fas only has to understand a small Foundry resource graph.

  3. Optimistic concurrency instead of locking. fas deploy checks that nothing has changed since the preceding plan before it writes.

    That works well as long as deploys don’t overlap. Run fas deploy twice against the same project at nearly the same time—from two developers, or from a developer and CI—and the later write can silently win. No merge conflict, no lock contention, just the earlier change overwritten.

    For one developer or a small team, that trade-off is probably acceptable. Once multiple people or pipelines are deploying the same project regularly, it needs stronger concurrency control. Today, fas doesn’t have that.

None of these ideas are novel. Declarative definitions, live-state diffing, and reconciliation loops have been standard practice in the Kubernetes ecosystem for a decade.

What fas doesn’t do

fas is deliberately scoped to Foundry accounts and projects: models, connections, toolboxes, and prompt agents. It isn’t a general-purpose Azure provisioning tool. It doesn’t handle multi-environment promotion from dev to stage to prod, and it doesn’t manage RBAC for you. As discussed above, it also has no deployment locking yet.

Treat it for what it is: a tooling experiment for a fast sandbox iteration loop, not something I’d point multiple developers and CI pipelines at in production.

And finally: where I land

None of this is an argument against IaC. Terraform’s state management and ARM/Bicep’s tracked deployment model earn their keep when you’re managing infrastructure with real interdependencies that changes relatively rarely. They’re just the wrong shape for agent definitions that may change every hour and, in many cases, aren’t ARM resources to begin with. Deployment tooling should match the lifecycle of the thing you’re changing, not just the category of platform it happens to live in.

The interesting question isn’t really whether you should use fas— you probably shouldn’t. It’s that the tooling gap is real enough that AWS has built a separate deployment path for it: the direct code deployment AgentCore Runtime added in November 2025, so developers don’t have to push every iteration through the heavier container or infrastructure path.

But look at what that alternative is: a ZIP upload. No plan, no live-state diff, no dependency graph. Just an imperative push, primarily positioned around faster prototyping and iteration. That’s the false choice I find interesting. Agent developers shouldn’t have to choose between pipelines designed for cloud infrastructure and a fast path that gives up declarative deployment semantics entirely.

A lightweight path that keeps plan-and-diff semantics, reads the platform’s live state, and drops the infrastructure-specific overhead is perfectly feasible. fas isn’t proof that I’ve found the right implementation. It’s just proof that this design space exists.

Keeping agents in application code remains a legitimate architecture that avoids most of this, but as discussed, I foresee that option narrowing as agents pick up identities, permissions, and audit requirements of their own.

If your team is deploying agents through IaC tooling today, I’d be curious where you drew the line: did agent definitions stay in the same pipeline as the infrastructure, move onto their own promotion path, or leave the platform entirely and go back into application code?

Appendix: why include the model deployment at all?

A fair question about this experiment is why put the model deployment in it at all. The agent isn’t an ARM resource, it’s created through the Foundry data-plane APIs. And architecturally, an agent definition doesn’t need to know anything about the model at all: it can reference an endpoint, and whatever sits behind that endpoint is the platform’s concern.

This doesn’t change the fact that a deployed agent that can actually answer a request still has to resolve to a specific model, and that choice can make or break the agent’s behavior. Run the same prompt and tools against a different model, or against a silently updated version behind the same endpoint, and you have a different agent and different eval results. So once the model deployment is abstracted as an endpoint, either that endpoint pins a model version, in which case the agent does know the model after all, just at one level of abstraction higher, or it doesn’t, and your evals stop being reproducible. In an organization where a platform team runs models as shared, governed endpoints, the model genuinely is infrastructure, and only the prompt, tools, and endpoint reference change fast. But while I’m iterating on an agent, I still should own the model choice from a behavior perspective: I might pin a version so an eval stays reproducible, try a smaller model for speed, or test latest model releases. I won’t change the model as often as I touch the prompt, but often enough that, for me, it belongs to my application development loop.

That’s why I decided that the smallest unit worth deploying and benchmarking here isn’t the agent alone, it’s a model plus an agent that can actually answer a request.

Azure splits that unit across two planes: the model deployment lives in ARM, next to networking and IAM, while the agent lives behind the Foundry data-plane APIs. That split is exactly what produced the deployment trace at the start of this post: Bicep and the ARM deployment wrapper for one half, a hook script spinning up a Python interpreter for the other.