AWS in Switzerland and Austria (Alps)

How Swisscom accelerates developer productivity with Kiro

by Marco Fischer, Ankush Jasathia, Beni Schmidt, and Fabian Hoffschröer on in Kiro Permalink Share

Many enterprise platform teams roll out AI coding agents such as Kiro to boost developer productivity, and then hit the same wall. The agent writes correct deployable code, but it does not know your AWS enterprise environment. It misses the network rules, identity boundaries, and compliance controls your organization enforces, so what it generates fails against your reality. Swisscom, a telecommunications provider in Switzerland, set out to fix that for its developers. The answer was to give the agents the one thing they lacked: knowledge of iAWS, Swisscom’s internal AWS environment.

The substance here is not a single tool. It is Swisscom’s knowledge of iAWS captured as structured service specifications that agents read and apply while a developer writes code. Swisscom runs that intelligence on Amazon Bedrock AgentCore, a managed runtime for agents that is not tied to any single integrated development environment (IDE), so the same agents work across different developer environments. To put it in front of developers with the least friction, Swisscom packages everything as a Kiro Power, the delivery construct that brings the agents into the Kiro IDE as a single bundle.

The result: developers ship compliant applications faster while spending less time on infrastructure plumbing. According to Swisscom, deployment tasks that once took days now take hours, and more than 500 Swisscom developers use these agents today. This post explains why Swisscom made these choices and how the pieces fit together, so your platform team can apply the same approach.

The problem: AI agents need to know your rules

Consider a typical request: deploy an application on Amazon Elastic Container Service (Amazon ECS). Kiro generates a technically correct AWS application. However, it doesn’t know about the company’s specific network requirements, AWS Identity and Access Management (IAM) restrictions, or security and compliance policies.

The deployment fails. The developer opens a support ticket. The platform team explains the same constraints they’ve documented dozens of times.

This is the gap between generic AI coding assistants and enterprise reality. The AWS Model Context Protocol (MCP) Server included in the Agent Toolkit for AWS provides rich domain knowledge including documentation, API references, and best practices. However, it has no context about your AWS enterprise environment, typically built as an AWS landing zone.

From templates to rules the agent applies. In traditional platform engineering, the answer was blueprints: rigid templates that constrained developers into compliant patterns but also limited flexibility, created dependency bottlenecks, and slowed down iteration. A developer who needed a slight variation from the blueprint often faced days of back-and-forth with the platform team.

With AI agents, the platform team can write those same constraints down as rules that the agent looks up and applies while it writes code. Rather than receiving a static template, each developer gets a solution that the agent has adapted to their situation and checked against the rules, without days of back-and-forth. The constraints don’t disappear; they get a smarter delivery mechanism.

The solution: iAWS intelligence on top of an AWS foundation

Swisscom’s solution has three layers. First, AWS MCP Servers provide the generic AWS foundation. Second, custom iAWS Agents running on AgentCore add iAWS-specific intelligence on top. Third, iAWS Flows orchestrate the first two layers through reproducible, multi-step workflows. Kiro reaches the agents through the MCP Proxy for AWS, which signs each request with the developer’s AWS credentials.

For developers using Kiro, Swisscom packages this entire stack as the iAWS Agents Kiro Power, a single bundled configuration that includes the iAWS Agents plus three optional AWS MCP Servers (AWS, Amazon EKS, and Amazon ECS). The power activates on demand when conversations match relevant keywords, so agents receive iAWS and AWS capabilities without loading every tool up front.

Developers see the result in two kinds of everyday work: building something new, and fixing something that broke.

Building a new service. A developer needs a REST API that stores data in a database on iAWS. Instead of a generic answer, the iAWS Platform Agent starts from Swisscom’s own reference AWS Cloud Development Kit (AWS CDK) blueprint and proposes a private Amazon API Gateway, AWS Lambda, and Amazon DynamoDB design. The encryption and backup settings that iAWS requires are already in place, so the first version the developer deploys already follows iAWS rules.

Fixing a broken deployment. A developer reports connectivity problems with an Amazon Elastic Kubernetes Service (Amazon EKS) cluster. Kiro retrieves the matching troubleshooting iAWS Flow from the iAWS Support Agent and follows it. First, it uses the EKS MCP server to read the cluster’s networking configuration, security groups, subnets, and endpoint access setting. Next, it checks the findings against the iAWS integration patterns to spot iAWS-specific misconfigurations, such as a missing Amazon Virtual Private Cloud (Amazon VPC) endpoint or a security group that violates the iAWS baseline. Finally, it returns a step-by-step fix that cites the relevant service specification. According to Swisscom’s platform team, what used to be a support ticket and a day of waiting now takes about two minutes of self-service.

In both cases, work that used to start with a support ticket now starts and ends in the IDE.

Architecture overview

Figure 1 shows how the three layers fit together. The following sections walk through each one.

Architecture diagram of the three layers. In the Kiro IDE, the iAWS Agents Kiro Power connects through the MCP Proxy for AWS to Layer 3, iAWS Flows; Layer 2, the iAWS Platform Agent and iAWS Support Agent on Amazon Bedrock AgentCore; and Layer 1, the AWS, Amazon EKS, and Amazon ECS MCP Servers with read-only access to Swisscom's AWS accounts.Figure 1: How Swisscom’s iAWS Agents reach developers in Kiro

Layer 1: AWS MCP Servers

This is the generic AWS knowledge every agent starts with, accurate about AWS, but blind to your environment. AWS MCP Servers provide AI assistants with secure, authenticated, read-only access to AWS services. Swisscom’s platform team supports three core servers, which developers enable in their IDE alongside the iAWS Agents:

  • AWS MCP (aws.mcp): Real-time AWS documentation, API references, and authenticated read-only API calls
  • EKS MCP (aws.eks.mcp): Specialized Amazon EKS documentation and read-only API access
  • ECS MCP (aws.ecs.mcp): Dedicated Amazon ECS documentation and read-only API access

Layer 2: iAWS Agents (iAWS intelligence)

This is where the agent stops guessing about your environment and starts knowing it. AWS MCP Servers are direct API proxies with no large language model (LLM) involved. iAWS Agents work differently. They are LLM-powered agents hosted on Amazon Bedrock AgentCore and exposed as MCP servers through the same MCP Proxy for AWS. They search curated knowledge bases to deliver iAWS-specific answers and guidance on how to build efficiently on iAWS:

iAWS Platform Agent gives developers iAWS knowledge from the Swisscom DevOps Portal. It covers available products and services in the catalog, IAM permissions and restrictions, compliance policies, service-specific requirements, and integrations such as Shared VPC, DNS, and bootstrapping. Example queries include:

  • “Do I have permissions to use Amazon Bedrock on iAWS?”
  • “What products are available on iAWS?”
  • “What compliance policies apply to Amazon Simple Storage Service (Amazon S3)?”
  • “Can I create Amazon Relational Database Service (Amazon RDS) instances in eu-central-2?”
  • “How do I build a REST API that connects to a database on iAWS?”

Figure 2 shows how the agent answers the last of these questions.

The iAWS Platform Agent in Kiro answering a developer's request to build a REST API backed by a database on iAWS.

Figure 2: The iAWS Platform Agent answering a developer’s request to build a REST API backed by a database on iAWS.

iAWS Support Agent searches resolved iAWS support tickets for similar issues, lists iAWS Flows templates by product, and uses historical support data so developers can help themselves. A knowledge base built from Swisscom’s resolved iAWS support tickets and the iAWS Flows template library backs the agent. When a developer describes a problem, the agent retrieves the closest past resolutions. In the IDE, Kiro combines these resolutions with live, read-only resource inspection through the AWS MCP Servers, so the developer gets a concrete fix rather than a generic answer. The AWS MCP Servers run once, in the developer’s IDE; the Support Agent does not duplicate them.

Layer 3: iAWS Flows (orchestrated workflows)

This is what turns scattered answers into a repeatable procedure the agent follows every time. The iAWS Support Agent serves iAWS Flows from AgentCore; the agent in the developer’s IDE, such as Kiro, then carries out the steps, using the AWS MCP Servers to inspect resources along the way. iAWS Flows are written as Agent SOPs (standard operating procedures), an open format from the Strands Agents project for describing agent workflows in plain Markdown. An SOP sits between two extremes: a hard-coded workflow, which is predictable but costly to change, and a free-running agent, which adapts to anything but is hard to steer. Each step states what the agent MUST, SHOULD, or MAY do, using the same RFC 2119 keywords as Swisscom’s service specifications, and takes parameters so one Flow can serve many teams and services.

Swisscom chose Agent SOPs for three reasons. The platform team can write and update a Flow in plain language, without prompt engineering or code. The constraint keywords keep results consistent from one run to the next, which matters when the output is production infrastructure. And because SOPs are plain Markdown served over MCP, the same Flows work in Kiro and in other MCP-compatible clients. Swisscom uses Flows across the development lifecycle:

  • Exploration and learning: Developers discover iAWS capabilities through self-contained workflows
  • Code generation: AI agents reference Flows as templates for generating compliant code
  • Verification: Flows include validation checkpoints to confirm generated code meets requirements
  • Troubleshooting: Structured diagnostic workflows help identify and resolve issues systematically

What powers the agents: Structured iAWS knowledge

The iAWS Agents are only as good as the iAWS knowledge they can look up. Rather than loading one large knowledge base into every conversation, Swisscom keeps that knowledge in small, versioned documents. Each one describes a single part of iAWS in a fixed structure, so an agent can find the right rule and apply it without guessing:

  • Service specifications: Swisscom-specific service requirements including IAM permissions, preventive and detective controls, such as service control policies (SCPs) and resource control policies (RCPs), and integration requirements
  • Integration patterns: Normative, verifiable contracts for integrating with iAWS (Shared VPC, DNS, observability) using RFC 2119 keywords (MUST, SHOULD, MAY)
  • FinOps patterns: Structured requirements for cost optimization with trade-off analysis
  • Migration patterns: Guided workflows for transitioning from on-premises to iAWS

Swisscom generates these specifications from the iAWS codebase and blueprints that enforce the rules, and regenerates them when that code changes. The specification therefore describes what iAWS enforces, not what it once intended.

A service specification is deliberately small and declarative. For example, the rules for Amazon S3 might read:

# S3 service specification, MyPlatform
service: s3
version: 2026-04
constraints:
  encryption:
    requirement: MUST
    type: SSE-KMS
    key: customer managed key
  public_access:
    requirement: MUST
    block_public_acls: true
    block_public_policy: true
  logging:
    requirement: SHOULD
    destination: central-logging-bucket
  regions_allowed: [eu-central-1, eu-central-2]

A specification like this is a declaration of intent, not an enforcement mechanism on its own. Swisscom backs each rule with preventive and detective controls, including SCPs and RCPs. It also validates generated code against the specification before deployment. As a result, guardrails, not trust, enforce the MUST and MUST NOT constraints.

Lessons learned

Rolling this out to more than 500 developers taught the platform team two lessons.

AI coding requires context, not data volume

Flooding an AI agent with everything a platform team knows does not produce better results; it produces noise. Swisscom’s specifications and patterns deliver exactly the context an agent needs at each phase of a task (Plan, Build, Reflect), no more.

The same knowledge artifacts can be used across the entire lifecycle: from discovery through development and verification to support and troubleshooting. A service specification that helps an agent generate compliant infrastructure code during development also helps the Support Agent diagnose misconfiguration issues in production. The same iAWS Platform Agent can also be registered as a tool in AWS DevOps Agent, so incident investigations use the same rules developers see in Kiro. Context is reused, not duplicated, and it is rooted in the actual state of iAWS and its applications.

Empower, don’t prescribe: the platform team’s new mission

For developers, this approach means freedom: you’re not locked into a specific template or toolchain. You describe what you need, and the AI agent, armed with full iAWS context, figures out how to deliver it compliantly. The platform team’s role shifts from gatekeeping to empowering developers.

Conclusion

With this approach, enterprises can embrace AI-driven development while maintaining security, compliance, and governance. Swisscom’s implementation of iAWS Agents and AWS MCP Servers shows what that looks like in practice.

Next, Swisscom plans to expand its service specifications, integration patterns, and blueprint patterns alongside development teams, and to keep those capabilities discoverable as the catalog of agents and Flows grows. Swisscom has also started connecting AWS DevOps Agent to iAWS: the iAWS Platform Agent is registered as a tool inside DevOps Agent, so incident investigations draw on the same rules developers use in Kiro. Swisscom is also exploring how AWS Continuum can help find and fix security risks earlier in the software lifecycle.

Get started

If you’re starting your own agentic SDLC journey, you can follow Swisscom’s approach as a practical blueprint. Write your environment’s rules as small, structured specifications. Use MCP to give agents secure access to them. And let your platform team supply that knowledge to developers’ agents, rather than act as a gatekeeper for AI adoption.

Start with the Agent Toolkit for AWS. Paste the following prompt into your coding agent, such as Kiro, Claude Code, Codex, or other MCP-compatible tools:

Set up Agent Toolkit for AWS by following these instructions:
https://raw.githubusercontent.com/aws/agent-toolkit-for-aws/refs/heads/main/setup-instructions/setup.md

To build your own platform-aware AI agents, start with these resources: