The infrastructure dashboard is green. The Microsoft Foundry project is live, the model is connected, the agent is deployed, and its tools are configured. The platform team is ready to celebrate—but the application team still has one critical question : Can we trust this agent from our side of the handover?
A Microsoft Foundry handover story
The infrastructure team has finished the AI landing zone. The Microsoft Foundry project exists. The prompt agent is already created, connected to its model, and configured with the tools or connections it needs.
That is an important milestone, but it is not the same as saying the application team is ready to use it.
At handover, the question should be simple:
Can the application team call the existing Foundry project endpoint and the named agent, using the expected identity, and get useful evidence that the agent can reach its configured services?
The application team should not be handed a test that creates another LLM client or rebuilds integrations locally. That may prove a script works, but it does not prove the handed-over agent is ready.
Handover GapThe challenge with poor handover
In many projects, handover sounds like this:
"The agent is deployed."
But the receiving team hears a different message:
"The platform is ready for application integration."
Those two statements are not always the same.
As a Senior Cloud Solution Architect, this is where I usually see confusion begin. The portal demo may work. The resources may exist. The model may be attached. But the application team still needs to know whether the runtime contract works from their side of the boundary.
Without a clear handover check, teams can validate the wrong thing. A developer may write a local test that calls a model directly, connects to search directly, or uses a different identity path. The test may pass, but it has bypassed the actual Foundry prompt agent.
That creates a dangerous result: a green test for the wrong architecture.
What a good handover should prove
A useful handover does not need to test every business scenario. It should prove the basics that matter before the application depends on the agent:
- The application identity can authenticate without secrets.
- The Foundry project endpoint is reachable.
- The named prompt agent can be found.
- The agent can be invoked through the intended boundary.
- The agent can use the services that are part of its configured contract.
- The result is recorded clearly as PASS, FAIL, or SKIP.
The better pattern - Agent Acceptance Gateway
The handover should feel like a relay race, not a treasure hunt.
The infrastructure team hands over the project endpoint, the agent name, and the identity expectations. The application team runs a small passwordless validator from its side. The validator does not recreate the solution. It checks the existing agent.
That distinction matters. The validator is not a second implementation of the agent, and it does not connect directly to the model, Azure AI Search, Azure Cosmos DB, or Azure Blob Storage. It approaches the solution exactly as the application will: through the handed-over Microsoft Foundry project endpoint and the named agent.
The infrastructure team owns the platform-side readiness. It confirms that the project and agent exist, the agent version is the intended one, required tools and connections are configured, network paths are available, and the application's managed identity has the minimum RBAC permissions needed to invoke the agent.
The application team owns the consumer-side acceptance check. It runs the validator from the real application environment using ManagedIdentityCredential, not a developer login or stored secret. This proves the runtime identity, DNS, routing, private endpoint configuration, and authorization path that production will use.
Validation flow
The validator follows the same six checks as the handover checklist. Requests travel through the Foundry project and named agent; the validator never connects directly to Search, Cosmos DB, or Blob Storage. The service probes should use known, non-sensitive test data. Avoid prompts that return secrets, personal data, or entire documents merely to prove connectivity.
What the validator could look like
The following Python is intentionally illustrative. It shows the responsibilities and control flow rather than prescribing exact SDK methods, which can change between package versions. Adapt the agent lookup and invocation calls to the SDK and agent type your organization has standardized.
# Illustrative flow only: align method names with the SDK version you use.
import os
from azure.identity import ManagedIdentityCredential
from azure.ai.projects import AIProjectClient
from dotenv import load_dotenv
load_dotenv() # Local convenience; Azure supplies the same values as app settings.
def validate_agent_handover(project_endpoint: str, agent_name: str) -> dict:
"""Check the handed-over agent without rebuilding its integrations."""
client_id = os.getenv("AZURE_CLIENT_ID")
credential = (
ManagedIdentityCredential(client_id=client_id)
if client_id else ManagedIdentityCredential()
)
results = {
"identity": "SKIP", "endpoint": "SKIP", "agent": "SKIP",
"invocation": "SKIP", "services": "SKIP", "report": "SKIP",
}
try:
credential.get_token("https://cognitiveservices.azure.com/.default")
results["identity"] = "PASS"
except Exception as exc:
results["identity"] = f"FAIL: {exc}"
return results
try:
client = AIProjectClient(endpoint=project_endpoint, credential=credential)
results["endpoint"] = "PASS"
agent = client.agents.get(agent_name=agent_name) # conceptual lookup
results["agent"] = "PASS" if agent else "FAIL: agent not found"
except Exception as exc:
results["endpoint"] = f"FAIL: {exc}"
return results
try:
response = client.agents.run(
agent_name=agent_name,
messages=[{
"role": "user",
"content": "Return OK and identify which configured data source you used.",
}],
) # conceptual invocation
results["invocation"] = "PASS" if response else "FAIL: no response"
results["services"] = "PASS" # evaluate expected probe evidence here
except Exception as exc:
results["invocation"] = f"FAIL: {exc}"
results["report"] = "PASS"
return results
if __name__ == "__main__":
print(validate_agent_handover(
os.environ["FOUNDRY_PROJECT_ENDPOINT"],
os.environ["FOUNDRY_AGENT_NAME"],
))
Configure passwordless identity
ManagedIdentityCredential deliberately restricts the validator to Azure managed identity. It does not fall back to an Azure CLI login, developer credential, environment secret, or interactive browser. This makes the acceptance result evidence for the application workload’s real runtime identity.
Before running the validator in Azure, enable managed identity on the hosting resource and grant that identity the least-privileged roles required to access the Foundry project and invoke the agent. The agent’s own connections remain configured and authorized separately by the infrastructure team.
Example .env file
Use an environment file only for local convenience. Do not commit it. In Azure App Service, Azure Functions, Azure Container Apps, or AKS, provide the same values through the platform’s application settings or workload configuration.
# .env contains identifiers and configuration—not a password or API key.
FOUNDRY_PROJECT_ENDPOINT=https://<project-name>.<region>.api.azureml.ms
FOUNDRY_AGENT_NAME=<handed-over-agent-name>
# Set only when the workload uses a user-assigned managed identity.
AZURE_CLIENT_ID=<managed-identity-client-id>
Run the validator
# Install the SDK packages selected by your application team.
python -m pip install azure-identity azure-ai-projects python-dotenv
# Run from an Azure compute resource that has managed identity enabled.
# System-assigned identity: omit AZURE_CLIENT_ID.
python validator.py
# Azure-hosted workload: enable managed identity, assign the required RBAC roles,
# add the non-secret environment variables above, and start the same command.
python validator.py
ManagedIdentityCredential is intended to run on Azure compute with managed identity enabled. Run the handover gate from the application’s deployed environment so the result proves the intended identity, network route, DNS, private endpoints, and role assignments. For a user-assigned identity, set AZURE_CLIENT_ID to its client ID; for a system-assigned identity, omit that setting.
Probe prompts for configured services
If Azure AI Search, Azure Cosmos DB, or Azure Blob Storage are part of the agent’s contract, the validator sends focused probe prompts through the agent and records the outcome. If a service is not part of the contract, that probe is marked SKIP rather than assumed.
|
Service |
Example probe prompt |
Expected evidence |
|
Azure AI Search |
“List the top three documents in your index about [known topic]. Include titles and short snippets.” |
Document titles and relevant snippets from known indexed content. |
|
Azure Cosmos DB |
“What is the most recent record timestamp in the configured data source?” |
A valid timestamp that can be checked against a known range. |
|
Azure Blob Storage |
“Confirm that you can access the configuration file at [known path]. Return metadata only.” |
Expected file name, content type, last-modified time, or a safe summary. |
These probes test the agent’s actual tool connections without requiring the validator to authenticate to those services directly. A strong acceptance result records the prompt, status, timestamp, correlation or run identifier, and a small piece of expected evidence—without storing sensitive response content.
The result gives both teams the same evidence. Instead of asking whether the agent was deployed, they can ask the better question:
Is the agent ready for the application to use?
Closing thought
Deploying an agent is only the first half of the journey. The real test is whether the application team can use it confidently through the expected
identity, network, and capabilities.
The Agent Acceptance Gateway creates that moment of confidence. It brings both teams together, checks what matters, shows what still needs attention, and turns the handover into a shared decision.
The goal is simple: do not hand over an agent just because it exists. Hand it over when both teams have clear evidence that it is ready.