Getting Started with
Agentic AI

01 The Mind Shift: What Kiro CLI Actually Is

You've used a chatbot — you type a question, it answers, you copy-paste the result somewhere. That's a conversation. An agentic CLI like Kiro CLI?Kiro is actually a full IDE built by AWS — but it's ultra-flexible and can do much more than just coding. Kiro CLI is its command-line interface, which is what we focus on here. There's also a Kiro UI for those who prefer a graphical interface, with a focus on software development. is something fundamentally different: it's an AI that can take actions on your computer — read your files, run shell commands, call APIs, write code, and loop autonomously until a task is done.

Kiro CLI is built by AWS and runs right in your terminal. It connects to frontier AI models and has access to tools — the ability to read and write files, execute shell commands, fetch, read and understand web content, and more. The key insight: the AI doesn't just know things, it can do things. You describe what you want, and it figures out the steps, executes them, and learns from its mistakes along the way.

02 Kiro CLI Quickstart

Let's get Kiro CLI running on your machine in under 5 minutes. You'll need macOS or Linux (Windows users: use Windows Subsystem for Linux (WSL) or the Kiro GUI). See the official installation docs for full details.

Install

# One-liner install (macOS / Linux)
curl -fsSL https://cli.kiro.dev/install | bash

Log In

# Start Kiro CLI — it will prompt you to log in on first run
kiro-cli
# Select "Use for Free with Builder ID"
# A browser window opens — sign in, and you're ready to go.

Your First Agentic Task

Here's where it gets exciting. Instead of asking the AI a question and copy-pasting the answer, you give it a task — and it does the work for you. Try this:

# Inside Kiro CLI, just type your task in plain English:
> Create a simple Python web scraper that fetches the top
  headlines from AWS News and prints them to the terminal

Watch what happens — the agent thinks through the problem, tries different approaches, writes the code, and then runs it to verify it works:

Useful Slash Commands

/context      # See & configure where Kiro reads context from
/context show # Show which steering files, rules & skills are active
/tools        # Show available tools the agent can use
/mcp          # List active plugin servers (more on this in Section 03)
/model        # Switch AI model mid-conversation (with tab completion)
/clear        # Clear conversation history and start fresh
/help         # Full command reference

03 Supercharging with MCP Servers & Skills

Out of the box, Kiro CLI can read files, run commands, and fetch web pages. That's already powerful, but the real magic starts when you plug in MCP servers?Model Context Protocol (MCP) is an open standard — originally introduced by Anthropic — that lets AI agents connect to external tools and data sources. Think of MCP servers as plugins: each one gives your agent new abilities. There's a growing directory of MCP servers for everything from AWS docs to GitHub to databases. and Skills?Skills are instruction bundles that teach an agent how to do specific tasks well. The concept was introduced by Anthropic for Claude Code and is now an open standard adopted by multiple tools — including Kiro. Anthropic maintains a collection of ready-made skills at github.com/anthropics/skills. — giving the agent entirely new capabilities like searching AWS documentation, working with Excel files, or querying databases.

What is MCP?

Adding an MCP Server

Let's add the AWS Documentation MCP server so Kiro can search official AWS docs directly. First, quit Kiro CLI if it's running (type /quit), then install the uv Python package manager which is needed to run the MCP server:

# Install uv — a fast Python package runner. Many MCP servers
# are Python tools, and "uvx" (part of uv) runs them without
# manual installation.
curl -LsSf https://astral.sh/uv/install.sh | sh

Now register the MCP server with Kiro:

# Add the AWS Documentation MCP server globally
kiro-cli mcp add \
  --name "awslabs.aws-documentation-mcp-server" \
  --scope global \
  --command "uvx" \
  --args "awslabs.aws-documentation-mcp-server@latest" \
  --env "FASTMCP_LOG_LEVEL=ERROR" \
  --env "AWS_DOCUMENTATION_PARTITION=aws"

The config is stored in ~/.kiro/settings/mcp.json — you can also edit that file directly if you prefer. Now restart Kiro CLI and try it out:

# Start Kiro CLI and use your new tool:
kiro-cli

> What storage classes are available in S3 in
  the AWS region in Switzerland?

The agent now searches the official AWS documentation (not its training data) and gives you an accurate, up-to-date answer about S3 storage classes available in the Zurich region. That's the power of MCP — you're extending what the agent can access and know.

Skills: Teaching Kiro New Tricks

While MCP servers give the agent access to external tools and data, Skills teach the agent how to do specific tasks well. A Skill is a bundle of instructions, best practices, and sometimes MCP servers that Kiro loads when it detects a relevant task. Think of it as giving the agent a playbook for a particular job.

For example: out of the box, Kiro can't work with Excel files. But with the xlsx Skill, it learns how to read, create, and modify spreadsheets using the right libraries and patterns. See the official Skills documentation for details.

Adding a Skill

Anthropic maintains a collection of ready-made Skills at github.com/anthropics/skills. Let's add the Excel skill so Kiro can work with spreadsheets.?Skills are stored as SKILL.md files in ~/.kiro/skills/<name>/ (global) or .kiro/skills/<name>/ (project-local). You could copy the files there manually — but it's much easier to just ask the agent to do it for you, as shown below. Inside Kiro CLI, just tell it what you want:

# Inside Kiro CLI, ask it to install the skill:
> add the xlsx skill from
  https://github.com/anthropics/skills/tree/main/skills/xlsx
  as described in https://kiro.dev/docs/cli/skills/

Kiro will read the documentation, download the skill files, and configure everything. Afterwards, you can ask Kiro to read, create, and modify Excel files directly — it knows the right approach because the Skill tells it how.

04 Strands Agent SOPs: The Game Changer

So far you've seen how to give an agent a single task. But what about entire workflows — the multi-step processes you do manually every day? Think about it: reviewing documents, processing reports, checking logs, summarizing meetings. Normally, automating these requires writing code. What if you could just describe the workflow in plain English and have an agent execute it?

That's exactly what Agent SOPs (Standard Operating Procedures) do. Built by AWS and battle-tested by thousands of Amazon teams, SOPs are markdown files that describe a workflow step by step. You feed the SOP to an agent, and it follows the instructions — reading files, running commands, making decisions — just like a human would follow a checklist. Now they're open source.

SOPs borrow a simple convention from internet standards (RFC 2119) — special keywords that control how strictly the agent must follow each instruction:

MUST = the agent has to do this, no exceptions    SHOULD = strongly recommended, but agent can adapt    MAY = optional, agent decides

SOP Structure at a Glance

Why SOPs are Perfect for Rapid Prototyping

05 Creating & Using Your First SOP

The best way to start is to take something you already do — a prompt you type regularly — and turn it into a reusable SOP. Let's do that step by step.

From Everyday Prompt to Reusable SOP

Say you often ask an AI: "Fix the grammar issues and improve the flow of this text." That works, but you get different quality each time. Let's turn it into a consistent, reusable SOP:

Running SOPs in Kiro CLI?cd into the directory where your .sop.md file lives, then start kiro-cli from there. Inside Kiro, tab completion works for SOP filenames — just start typing and press Tab.

# Inside Kiro CLI:
> run text-polish.sop.md with draft-blogpost.md

Kiro reads the SOP, follows each step, creates the polished file and the changelog. Every time you run it, the result is consistent because the constraints and validation steps keep the agent on track.

Creating SOPs Conversationally

You don't even have to write the SOP by hand. You can ask Kiro to create one for you. But first, you need to teach it the SOP format. Just tell Kiro to fetch the formatting rule directly from GitHub:

> Read this rule and apply it: https://raw.githubusercontent.com/strands-agents/agent-sop/refs/heads/main/rules/agent-sop-format.md
# → Kiro downloads the rule and learns the SOP format.

Now Kiro knows how to write properly structured SOPs. Just describe the workflow you want:

> Create an SOP that takes a folder of CSV files, validates
  that each file has the required columns (date, amount,
  category), merges them into one file, and creates a
  summary with totals per category.

Kiro will generate a properly structured SOP with parameters, constraints, procedure, and validation — ready to use or refine.

06 SOPs with Code: The Full Power

The text-polish SOP above was fully agent-driven — every step was natural language. That's great for a prototype. But for steps that need to produce the exact same result every time, you can embed actual code snippets right in the SOP. The agent then runs that code instead of improvising.

Here's a real-world example: an SOP that downloads YouTube video transcripts and generates structured summaries. Notice how some steps are natural language (the agent reasons) and some are concrete code (deterministic execution):

Below is a condensed view. You can view the full SOP file here.

# Excerpt from the cleaning script embedded in the SOP:
import re, os, sys

video_id = sys.argv[1]
vtt_file = [f for f in os.listdir('.')
            if f.endswith('.vtt') and video_id in f][0]

# Strip VTT timing headers, inline tags, and duplicates
# ... (full script in the SOP file)

with open('subtitle.txt', 'w') as f:
    f.write(' '.join(cleaned))

See the pattern? Steps 1 and 2 are deterministic — the agent runs the exact commands and scripts specified. Step 3 is agent-driven — the AI uses its reasoning to create a good summary. This hybrid approach gives you reliability where it matters and flexibility where you need it.

Running It in Kiro CLI?cd into the directory where your .sop.md file lives, then start kiro-cli from there. Inside Kiro, tab completion works for SOP filenames — just start typing and press Tab.

# Inside Kiro CLI:
> run yt-summary.sop.md with
  https://www.youtube.com/watch?v=NrbzlvjX0GQ

The agent downloads the transcript, cleans it with the exact script provided, then uses its intelligence to create a concise, well-structured summary. Same result structure every time, but with the AI's reasoning for the creative parts.

07 Resources & Next Steps