Running AI Agents in Production with Azure App Platform

Building AI agents in a lab is exciting. Running them in production is where the real challenges begin. Microsoft Ignite 2025 session BRK116 revealed how Azure App Platform transforms AI agents from experimental prototypes into enterprise-grade systems that scale, secure, and operate reliably. This session showcased how apps, agents, and the Model Context Protocol (MCP) combine to create intelligent, autonomous systems—with real-world validation from companies like Hitachi.

From Reactive Applications to Proactive Agents

Traditional enterprise applications are reactive: users click buttons, submit forms, and wait for results. AI agents flip this model—they're proactive: monitoring data streams, reasoning about problems, and taking action autonomously.

This shift creates new operational demands:

Continuous operation: Agents run 24/7, not just when users interact
Dynamic resource needs: Agent workloads spike unpredictably based on events
Complex integrations: Agents invoke dozens of tools and APIs via MCP
Security at scale: Every tool invocation must be authenticated, authorized, and audited
Observability: You need to understand why agents make decisions, not just what they do
Governance: Compliance, cost control, and policy enforcement for autonomous systems

Azure App Platform addresses these challenges by providing the infrastructure, security, and management tools to run AI agents as first-class production workloads.

🇸🇪 Technspire Perspective: Swedish Energy Company Moves 23 Agents to Production

A Swedish renewable energy provider (4,200 employees) built 23 AI agents for their operations: grid load forecasting, turbine maintenance prediction, energy trading optimization, and customer demand response. Initial prototypes ran on developer laptops and ad-hoc VMs—brilliant demos, operational nightmares.

The production reality check: An agent crashed during peak trading hours, costing €180,000 in missed arbitrage opportunities. Another agent exceeded its Azure OpenAI quota, causing 4-hour outages. No audit trails meant compliance teams couldn't verify agent decisions for regulatory reporting.

The Azure App Platform transformation: Technspire architected a production-ready agent infrastructure:

Deployed agents on Azure App Service with autoscaling (handles 10x traffic spikes automatically)
Integrated Azure AI Foundry for unified agent lifecycle management (dev → staging → production)
Connected MCP tools via Azure API Management for rate limiting and circuit breaking
Implemented Application Insights for agent observability (trace every decision, tool invocation, and error)
Enforced governance policies via Azure Policy (cost caps, approved tools only, mandatory audit logging)

Results after 6 months: Zero agent-caused outages. 99.7% uptime across all 23 agents. Trading agent captures 94% of arbitrage opportunities (vs. 61% before). Maintenance prediction agent reduced turbine failures by 38%. Compliance audits take 2 days instead of 3 weeks—all agent decisions are logged and traceable.

Azure App Platform: The Agent Infrastructure

Azure App Platform isn't a single product—it's an integrated set of services designed to host, scale, and manage modern applications and AI agents:

Azure App Service

Fully managed platform for hosting web apps, APIs, and long-running agent processes. Provides automatic scaling, built-in load balancing, and deployment slots for safe agent updates. Agents run as WebJobs or containerized workloads.

Agent benefits: Zero infrastructure management. Scale from 1 to 100+ instances based on workload. Integrated with Azure Virtual Networks for secure tool access.

Azure AI Foundry

Unified platform for building, testing, and deploying AI agents. Provides agent templates, MCP tool integration, prompt management, and evaluation frameworks. Connects seamlessly to Azure OpenAI, Azure Machine Learning, and external models.

Agent benefits: Single interface for agent lifecycle. Version control for prompts and configurations. A/B testing for agent improvements. One-click deployment to App Service.

Azure API Management (APIM)

Gateway for agent-tool interactions. When agents invoke MCP tools, requests route through APIM for authentication, rate limiting, caching, and monitoring. Enforces policies like "agents can only call approved tools" or "limit to 1,000 tool invocations per hour."

Agent benefits: Protect backend tools from agent overload. Centralized security (OAuth, API keys, certificates). Detailed analytics on tool usage patterns.

Application Insights

Observability platform that captures agent telemetry: decision traces, tool invocation latencies, error rates, and performance metrics. Integrates with agent frameworks to log reasoning steps, tool results, and outcome evaluations.

Agent benefits: Debug agent behavior in production ("why did it choose this tool?"). Detect anomalies (sudden spike in failures). Track KPIs (agent success rate, average decision time).

Azure Policy & RBAC

Governance framework that enforces organizational rules on agent deployments. Policies can mandate cost caps, require specific security configurations, restrict tool access to approved registries, or enforce data residency requirements.

Agent benefits: Prevent runaway costs (auto-shutdown if spending exceeds budget). Ensure compliance (agents can't bypass security controls). Role-based access (only authorized teams deploy production agents).

MCP Tools: The Agent's Toolbox

Agents become powerful when they can use tools—and the Model Context Protocol (MCP) is how they discover and invoke those tools securely at scale.

In the Azure App Platform context, MCP tools enable agents to:

Access enterprise data: Query databases, read SharePoint documents, retrieve CRM records
Automate workflows: Trigger Logic Apps, call Power Automate flows, submit approval requests
Integrate external systems: Invoke SAP APIs, update Salesforce, send Slack notifications
Perform specialized tasks: Analyze images, transcribe audio, generate PDFs, run simulations

Traditional Tool Integration

✗ Hardcoded API endpoints in agent code
✗ Credentials stored in environment variables
✗ No rate limiting → backend overwhelm
✗ Manual tool discovery and updates
✗ Inconsistent error handling
✗ No visibility into tool usage patterns

MCP + Azure APIM Approach

✓ Dynamic tool discovery via registry
✓ Centralized auth via Azure Entra
✓ Built-in rate limiting and throttling
✓ Automatic tool versioning and rollback
✓ Circuit breakers for failing tools
✓ Complete observability and auditing

MCP Tool Flow in Azure App Platform

Agent needs a tool: "I need to check inventory levels for product SKU-12345"
Queries MCP registry: "What tools can query inventory?" → Azure API Center returns "InventoryAPI" tool
Authenticates via Entra: Agent presents its identity, receives scoped access token
Invokes tool via APIM: Request routed through API Management for policy enforcement
APIM applies policies: Rate limiting (not exceeded), caching (fresh data required), logging (audit trail created)
Tool executes: Backend inventory system processes query, returns data
Result logged: Application Insights captures latency (42ms), success status, data retrieved
Agent reasons: Uses inventory data to decide next action

This flow ensures every tool invocation is secure, governed, and observable—critical for production agent operations.

Live Demonstrations: Modernizing Apps into Intelligent Agents

The BRK116 session included powerful demonstrations showing how to transform traditional web applications into agent-driven intelligent systems:

Demo 1: Web App Modernization with GitHub Copilot

Starting with a legacy e-commerce web app (built with ASP.NET), the team demonstrated how GitHub Copilot rapidly modernizes codebases:

Codebase analysis: Copilot scanned the application, identified outdated patterns and security issues
Framework upgrades: Auto-suggested migrations to .NET 8, updated dependencies
Security fixes: Detected SQL injection vulnerabilities, generated parameterized queries
Performance optimization: Identified N+1 query problems, suggested caching strategies
API modernization: Converted SOAP endpoints to RESTful APIs

Result: What would take weeks of manual refactoring completed in hours with Copilot assistance. The modernized app was then ready for agent integration.

Demo 2: Intelligent Shopping Experience with AI Agents

The modernized e-commerce app was enhanced with AI agents that provide personalized, proactive shopping experiences:

Agent 1: Shopping Assistant

Engages customers with natural language conversations. "I'm looking for a winter jacket for hiking in Norway." Agent queries product database via MCP tool, filters by weather resistance and temperature ratings, suggests 3 options with explanations.

Agent 2: Inventory Optimizer

Monitors stock levels in real-time. When a trending product drops below threshold, agent automatically creates purchase orders, notifies suppliers via email (MCP tool), and updates expected delivery dates on the website.

Agent 3: Price Optimizer

Analyzes competitor pricing, demand patterns, and margin goals. Adjusts prices dynamically (within approved bounds) and triggers promotional campaigns via Marketing Automation tool when strategic opportunities emerge.

Technical implementation:

Agents deployed on Azure App Service with autoscaling (3-15 instances based on traffic)
MCP tools exposed via Azure API Management (rate limiting: 10,000 calls/hour per agent)
Application Insights tracks agent conversations (95% user satisfaction score detected)
Azure AI Foundry manages agent versions (A/B test new conversation flows before full rollout)

🇸🇪 Technspire Perspective: Swedish Fashion Retailer's Agent-Driven Transformation

A Swedish fashion e-commerce company (1,200 employees, 3.5M customers) had a traditional web storefront with manual merchandising, fixed pricing, and reactive customer service. Customer lifetime value (CLV) was stagnant at €280, and cart abandonment hit 72%.

The agent vision: Transform the shopping experience with AI agents that understand customer preferences, optimize inventory, and personalize every interaction.

The implementation: Technspire deployed 8 AI agents on Azure App Platform:

Style advisor agent: Uses customer history + fashion trends to suggest outfits (via Product Catalog MCP tool)
Size prediction agent: Analyzes past purchases + return reasons to recommend correct sizes (via Returns Database tool)
Inventory agent: Monitors stock, triggers supplier orders via EDI (via Supplier Gateway tool)
Dynamic pricing agent: Adjusts prices based on demand elasticity (via Pricing Engine tool)
Sustainability agent: Highlights eco-friendly products, calculates carbon footprint (via Sustainability API tool)
Returns optimizer agent: Pre-emptively offers size swaps before shipping to reduce returns
Re-engagement agent: Monitors abandoned carts, sends personalized recovery offers via SMS (via Twilio tool)
Trend forecasting agent: Analyzes social media + sales data to predict next season's demand (via Social Listening tool)

Infrastructure: All agents on Azure App Service (scale 5-40 instances), 47 MCP tools via Azure APIM, Application Insights for observability, Azure AI Foundry for agent management.

Results after 8 months: Cart abandonment dropped to 54% (-25%). CLV increased to €385 (+38%). Return rate fell from 28% to 19% (size prediction agent). Inventory costs reduced 15% (better demand forecasting). Customer satisfaction (NPS) rose from 42 to 68. The agents handle 83% of shopping assistance—human support focuses on complex cases only.

Enterprise Innovation: Hitachi's Proactive Maintenance Ecosystem

The session highlighted Hitachi's real-world transformation using Azure App Platform and AI agents—moving from reactive maintenance systems to predictive, autonomous operations.

The Challenge: Unplanned Downtime

Hitachi operates complex industrial equipment (elevators, HVAC systems, power grids) for clients worldwide. Traditional maintenance was reactive: equipment breaks, customers call support, technicians dispatched. This caused:

Customer dissatisfaction: Downtime disrupts operations (e.g., hospital elevator outages)
High costs: Emergency repairs cost 3-4x more than scheduled maintenance
Safety risks: Critical failures could endanger lives
Inefficient resource allocation: Technicians dispatched without knowing the problem, often lacked required parts

The Solution: AI Agents + Azure Platform

Hitachi built an agent-driven predictive maintenance ecosystem:

1. Data Collection Layer

• IoT sensors on 50,000+ equipment units (temperature, vibration, power consumption, runtime)
• Azure IoT Hub ingests 2.5M sensor readings per minute
• Data stored in Azure Data Lake for historical analysis
• Real-time streams processed via Azure Stream Analytics

2. Agent Intelligence Layer

• Anomaly detection agent: Monitors sensor patterns, flags deviations (e.g., bearing temperature 15% above normal)
• Failure prediction agent: Uses machine learning models to estimate time-to-failure (e.g., "elevator motor will fail in 14 days with 87% confidence")
• Maintenance scheduling agent: Optimizes technician routes, schedules repairs during off-peak hours
• Parts inventory agent: Ensures required components are pre-positioned before technician dispatch

3. Action Execution Layer

• Agents invoke MCP tools to execute workflows
• Customer notification tool: Sends proactive alerts ("Your elevator needs maintenance next Tuesday at 2 AM—no downtime expected")
• Work order tool: Creates technician assignments in field service system
• Inventory tool: Reserves required parts from nearest warehouse
• Logistics tool: Arranges part delivery to technician's location

Technical Architecture

Agent hosting: Azure App Service (auto-scales to 80 instances during peak analysis periods)
Agent orchestration: Azure AI Foundry (manages 12 agent types with versioning and rollback)
Tool integration: 34 MCP tools exposed via Azure API Management (SAP, Salesforce, internal systems)
Observability: Application Insights tracks 1.2M agent decisions per day
Governance: Azure Policy enforces data residency (EU customer data stays in EU regions)

Business Impact

Operational Metrics

• Unplanned downtime: -73% (from 4.2 hours/month to 1.1 hours/month)
• Emergency repairs: -68% (agents catch issues before failure)
• First-time fix rate: 94% (technicians arrive with correct parts and diagnosis)
• Maintenance costs: -41% (scheduled repairs cheaper than emergencies)

Customer Experience

• Customer satisfaction: +52 NPS points
• Proactive notifications: 89% of maintenance now scheduled in advance
• Equipment uptime: 99.4% average (up from 96.8%)
• Contract renewals: +34% (customers value predictive approach)

Hitachi's transformation demonstrates how Azure App Platform turns AI agents from prototypes into production systems that deliver measurable business value.

Built-In Observability: Understanding Agent Behavior

One of Azure App Platform's critical features for production agents is deep observability—the ability to understand not just what agents do, but why they make specific decisions.

Application Insights for Agents

Application Insights integrates with agent frameworks to capture:

📊 Performance Metrics

• Average agent response time (e.g., 2.3 seconds)
• Tool invocation latencies (which tools are slow?)
• Token consumption per decision (cost tracking)
• Autoscaling events (when do agents need more capacity?)

🔍 Decision Traces

• Full reasoning chain (user query → tool calls → final answer)
• Tool selection rationale (why this tool, not another?)
• Confidence scores for decisions
• Alternative paths considered but rejected

⚠️ Error Tracking

• Tool invocation failures (timeouts, auth errors, rate limits)
• Agent reasoning errors (hallucinations, invalid tool calls)
• Dependency failures (downstream service outages)
• User-reported issues ("agent gave wrong answer")

📈 Business KPIs

• Agent success rate (task completion %)
• User satisfaction scores
• Business outcomes (revenue per agent interaction)
• Compliance metrics (all decisions auditable)

Debugging Agent Decisions

When an agent makes a wrong decision, Application Insights provides full replay capabilities:

Find the problematic interaction in the logs (search by user ID, timestamp, or error code)
View the complete reasoning trace: user input → agent's understanding → tools considered → tool invocations → final response
Identify the failure point (e.g., agent misunderstood user intent, tool returned stale data, timeout occurred)
Reproduce the issue in staging environment with same inputs
Fix the problem (update prompt, add error handling, implement caching)
Deploy updated agent version, validate fix in production

This level of observability is essential for continuously improving agent quality based on real-world interactions.

Access Controls and Policy Enforcement

Production agents require robust security and governance—Azure App Platform provides multiple enforcement layers:

1. Identity and Authentication

Microsoft Entra Agent ID: Every agent has a unique identity with scoped permissions
Managed identities: Agents authenticate to Azure services without storing credentials
User delegation: Agents inherit user permissions (can only access data the user is authorized to see)
Service principals: For background agents, assign specific roles (e.g., "read-only access to sales database")

2. Tool Access Controls

Registry-level controls: Only approved agents can discover tools in Azure API Center
Tool-level permissions: Agent A can invoke EmailTool, but not DatabaseDeleteTool
Rate limiting: Each agent has quotas (e.g., 1,000 tool calls per hour)
Circuit breakers: Auto-disable agents that exceed error thresholds

3. Policy Enforcement

Azure Policy ensures agents comply with organizational rules:

Cost Governance

Policy: "Agents must not exceed €500/day in Azure OpenAI costs." If limit approached, policy auto-throttles requests or switches to smaller models.

Data Residency

Policy: "Customer data for EU clients must stay in EU Azure regions." Prevents agents from invoking tools that would route data through US servers.

Audit Logging

Policy: "All agent-tool interactions must be logged for 7 years (financial regulations)." Enforces logging to immutable storage, prevents log deletion.

Security Baselines

Policy: "Agents must use TLS 1.3+ for all communications, require MFA for human approvals, scan tool outputs for sensitive data." Auto-blocks non-compliant configurations.

Getting Started: Agent Deployment Roadmap

Ready to move your AI agents from prototypes to production on Azure App Platform? Here's how Technspire guides Swedish organizations:

Agent Inventory and Requirements (1-2 weeks)

• Catalog existing agents (experimental, staging, production)
• Document tool dependencies (what APIs/data does each agent need?)
• Define SLAs (uptime, response time, error rate targets)
• Assess security requirements (data sensitivity, compliance rules)
• Estimate resource needs (expected traffic, autoscaling requirements)

Infrastructure Setup (2-3 weeks)

• Deploy Azure App Service plans (choose tier based on SLA requirements)
• Configure Azure AI Foundry for agent lifecycle management
• Set up Azure API Management for MCP tool gateway
• Enable Application Insights for observability
• Configure Azure Entra for agent identities and RBAC
• Implement network security (VNets, private endpoints, firewalls)

Tool Integration via MCP (3-4 weeks)

• Build or adopt MCP servers for required tools
• Register tools in Azure API Center
• Configure authentication flows (OAuth, managed identities)
• Set rate limits and quotas per agent/tool combination
• Test tool invocations from staging agents
• Document tool capabilities for agent developers

Pilot Agent Deployment (4-6 weeks)

• Select 1-2 high-value agents for initial production deployment
• Deploy to staging environment, run load tests
• Validate observability (can you debug agent decisions?)
• Test failure scenarios (what happens if tools are down?)
• Deploy to production with canary rollout (5% traffic → 100%)
• Monitor for 2 weeks, gather feedback

Scale to Full Agent Fleet (8-12 weeks)

• Migrate remaining agents to Azure App Service
• Implement CI/CD pipelines for agent deployments (GitHub Actions, Azure DevOps)
• Configure autoscaling rules based on observed traffic patterns
• Set up alerting for SLA violations (uptime, error rates)
• Train teams on agent operations (deployment, monitoring, troubleshooting)
• Establish governance review process (quarterly policy audits)

Continuous Improvement (Ongoing)

• Analyze agent performance data weekly (identify slow tools, high-error agents)
• Run A/B tests on agent improvements (new prompts, different models)
• Optimize costs (switch to smaller models where quality is sufficient)
• Expand tool catalog (add new capabilities based on agent needs)
• Review compliance (ensure audit logs meet regulatory requirements)
• Measure ROI (cost savings, efficiency gains, revenue impact)

Why This Matters for Swedish Organizations

Sweden's businesses are building AI agents rapidly—but many struggle with the transition from prototype to production. Azure App Platform addresses critical challenges:

Regulatory compliance: GDPR, NIS2, AI Act—Azure's built-in governance and audit trails simplify compliance
Operational reliability: Autoscaling, circuit breakers, and observability ensure 99%+ uptime
Security by default: Entra authentication, private endpoints, and policy enforcement protect sensitive data
Cost control: Quotas, rate limiting, and model optimization prevent runaway spending
Developer productivity: MCP tool integration, GitHub Copilot modernization, and Azure AI Foundry reduce development time by 60-70%
Scalability: From 1 agent to 100+ agents without infrastructure rewrites

Ready to Move Your AI Agents to Production?

Technspire helps Swedish organizations deploy secure, scalable, and governed AI agents on Azure App Platform. From infrastructure design to tool integration to operational excellence—we're your partner in production agent deployment.

Schedule Your Agent Infrastructure Assessment

Key Takeaways from BRK116

✓ Azure App Platform provides complete infrastructure for production AI agents: hosting, scaling, security, governance
✓ MCP tools integrate via Azure API Management, ensuring secure, rate-limited, and observable agent-tool interactions
✓ Application Insights enables deep observability: understand why agents make decisions, debug production issues
✓ GitHub Copilot accelerates app modernization, preparing legacy systems for agent integration
✓ Hitachi's real-world success: 73% reduction in unplanned downtime, 41% lower maintenance costs
✓ Azure AI Foundry manages agent lifecycle: version control, A/B testing, safe deployments
✓ Built-in governance: cost controls, data residency, audit trails, compliance reporting
✓ Organizations report 99%+ agent uptime and 60-70% faster development cycles

The journey from AI prototype to production-grade agent is complex—but Azure App Platform removes the infrastructure barriers. As demonstrated in BRK116, organizations like Hitachi are already reaping the benefits: autonomous systems that scale reliably, operate securely, and deliver measurable business value. For Swedish organizations ready to move beyond experimentation, Azure App Platform provides the foundation for sustainable agent innovation.

Running AI Agents in Production with Azure App Platform - Microsoft Ignite 2025