
What's New in Kiro IDE 1.0: A Deep Dive into Every Feature
Kiro IDE 1.0 marks a significant milestone in agentic software development. This release puts developers firmly in the driver's seat with a new permissions system, custom agents, an experimental agent-first layout, natural language hooks, dockable chat tabs, session export, and more.
Overview
Kiro IDE 1.0 is built around one philosophy: you should control what the agent can do, while the agent handles the how. This release introduces a capability-based permissions system, lets you build and switch between specialized agents, and introduces an experimental Agent Focus mode for directing parallel agents. It also brings natural language hook creation, dockable chat tabs, and session export.
Let's break down each feature in detail.
1. Agent Focus Mode (Experimental)
The shift from code-first to chat-first development.
The way developers work with AI is changing. Models can now plan and execute multi-step work, so many developers spend their day guiding agents rather than directly editing every line of code. Agent Focus is Kiro's answer to this shift — an experimental new view that puts your interaction with agents front and center.
What It Does
Agent Focus is a chat-first layout designed for developers who spend their day directing agents. You can launch multiple sessions that work independently and in parallel across multiple workspaces. You describe what you want, refine it through conversation, kick off the work, and check in as the agent makes progress.

The Three-Panel Layout
- Agents Panel (Left): Create new sessions, browse them grouped by workspace, and see each session's status at a glance — whether it is working, blocked on your input, or paused.
- Chat Panel (Center): A revamped chat experience for guiding the agent, refining intent, and watching work unfold. File changes show up as inline code diffs so you can follow along without switching views.
- Auxiliary Panel (Right): Hidden until needed. The agent surfaces it to show changed files and spec summaries, or you open it yourself for a closer look.
Seamless Switching
Toggle between Agent Focus and the traditional IDE from the top-right corner of the window. Your work carries over in both directions — no progress is lost when you switch. Start with structured workflows (Spec, Plan, Bug Fix, Quick Spec) or freeform chat.
Real-World Example: Building a Microservice in Parallel
Imagine you're building a new user authentication microservice. With Agent Focus, you can run parallel sessions:
Session 1 — API Layer:
You: "Create a REST API with /signup, /login, and /refresh-token endpoints using Express.js and JWT. Follow our existing auth patterns in src/middleware/."
Session 2 — Database Layer (running simultaneously):
You: "Set up a PostgreSQL schema for user accounts with email verification tokens, password reset flows, and session tracking. Use Knex migrations."
Session 3 — Infrastructure:
You: "Write a Dockerfile and docker-compose.yml for the auth service. It needs PostgreSQL 16, Redis for session cache, and a Node 20 runtime."
All three sessions work independently. You monitor status in the left panel, step into whichever needs input, and switch to the full IDE when you want to review the generated code side by side.
Why It Matters
For developers who are orchestrating agents rather than writing every line themselves, the traditional file-tree-and-editor layout is the wrong default. Agent Focus gives you a purpose-built surface for that workflow while keeping the full IDE a single click away.
2. Capability-Based Permissions System
Define exactly what the agent can and cannot do.
IDE 1.0 gives you explicit control over what the agent can do through a capability-based permissions system. The agent asks for approval before performing operations you haven't explicitly allowed.
How It Works
Every file read, command execution, and MCP call is evaluated against your rules. The IDE prompts for consent on anything you haven't pre-approved. When prompted, you can:
- Approve or deny the specific action
- Choose a broader pattern (e.g., allow all
npm *commands)
- Pick a scope — workspace-level or global
Zero-Configuration Start
No setup is required to start. Sensible defaults apply out of the box, and your policy grows organically as you make consent decisions during your work. Over time, you build a complete, auditable ruleset without ever touching a config file directly.
Unified Permission Model
Write one rule to allow
npm * commands across every session, or deny .env reads and have every tool respect it simultaneously. The visual consent flow builds your policy as you work.Example: Building a Permission Policy for a Team Project
Here's how a typical permission policy evolves during a real project:
Day 1 — Kiro asks to read your project files:
Agent wants to: Read file src/components/Button.tsx→ You approve with pattern: "Allow read src/**"→ Scope: Workspace
Day 1 — Kiro asks to run a build command:
Agent wants to: Execute command "npm run build"→ You approve with pattern: "Allow execute npm *"→ Scope: Workspace
Day 2 — Kiro tries to read environment secrets:
Agent wants to: Read file .env.production→ You DENY with pattern: "Deny read .env*"→ Scope: Global (applies to all your workspaces)
Day 3 — Kiro tries to call an MCP tool:
Agent wants to: Call MCP tool "aws-deploy:create-stack"→ You approve this specific call but choose "Ask every time" for deploy tools→ Scope: Workspace
Your resulting policy (built automatically):
# Workspace: my-projectrules: - allow: read src/** - allow: execute npm * - allow: write src/** - deny: read .env*
# Globalrules: - deny: read .env* - ask: mcp aws-deploy:*
Why It Matters
Previous versions of AI coding tools operated on trust-by-default. In production environments and team settings, this creates risk. Kiro 1.0's permissions give you declarative, auditable control — critical for enterprise adoption and individual developer confidence.
3. Custom Agents
Build specialized agents in minutes and share them with your team.
Custom agents let you create purpose-built AI assistants tailored to specific tasks — a code reviewer, a documentation writer, a security auditor, or anything else your workflow demands.
How to Create One
- Write a Markdown file in
.kiro/agents/
- Declare tool access with simple tags:
read,write,shell,web
- Embed MCP servers and permission rules inline
- Save it — your agent appears in the selector immediately
Team Sharing via Version Control
Because agents are plain Markdown files, you can commit them to your repository and share them with your entire team. Everyone gets the same specialized agents, configured the same way.
Mid-Session Switching
Switch between agents within a chat session without losing conversation history. The agent selector sits in the chat input bar alongside the model picker. Go from Default to a custom code reviewer to Spec mode in a single conversation.
Default Agent Preference
Set a preferred default agent that persists across restarts, so new sessions always start the way you want.
Example: Blueprint for a Code Reviewer Agent
Create a file at
.kiro/agents/code-reviewer.md :---name: Code Reviewerdescription: Reviews code changes for bugs, security issues, and style violationstools: - read - web---
# Code Reviewer Agent
You are a senior code reviewer. Your job is to review code changes and provide actionable feedback.
## Review Checklist- Security vulnerabilities (injection, XSS, CSRF, auth bypasses)- Performance issues (N+1 queries, memory leaks, unnecessary re-renders)- Error handling (missing try/catch, unhandled promise rejections)- Code style (consistent naming, DRY violations, dead code)- Test coverage (missing edge cases, fragile assertions)
## Response FormatFor each issue found, provide:1. **Severity:** Critical / Warning / Suggestion2. **Location:** File and line reference3. **Issue:** What's wrong4. **Fix:** Concrete code suggestion
## Constraints- Do NOT modify files — only suggest changes- Focus on substantive issues, not formatting nitpicks- If the code looks good, say so briefly
Example: Blueprint for a Terraform Agent
---name: Terraform Architectdescription: Designs and writes Terraform infrastructure codetools: - read - write - shellmcp_servers: - aws-docspermissions: allow: - execute terraform * - execute aws sts get-caller-identity deny: - execute terraform apply - execute terraform destroy---
# Terraform Infrastructure Agent
You are an infrastructure engineer specializing in AWS and Terraform.
## Guidelines- Always use modules from the terraform-aws-modules registry- Tag all resources with: Environment, Project, ManagedBy=Terraform- Use remote state with S3 backend and DynamoDB locking- Never hardcode credentials or account IDs- Always run `terraform fmt` and `terraform validate` after writing
## Workflow1. Read existing infra code to understand current state2. Propose changes with a plan summary3. Write the Terraform code4. Run `terraform validate` to check syntax5. Run `terraform plan` and show the diff (NEVER auto-apply)
Example: Blueprint for a Documentation Writer Agent
---name: Doc Writerdescription: Generates and maintains project documentationtools: - read - write---
# Documentation Agent
You maintain project documentation. When asked to document something:
1. Read the source code to understand behavior2. Check for existing docs that need updating3. Write clear, example-rich documentation4. Use JSDoc/TSDoc for inline code comments5. Update the README table of contents if structure changes
## Style Rules- Write for a developer who is new to the project- Every public function gets a one-line summary + params + return + example- Use realistic examples, not foo/bar- Include "Common Pitfalls" sections where relevant
Why It Matters
Different tasks call for different tool access, different context, and different personalities. Rather than one general-purpose agent that you constantly reconfigure, custom agents let you predefine the right setup for each job and switch between them frictionlessly.
4. Natural Language Hook Creation
Describe the automation you want, and Kiro generates the configuration.
Hooks are event-driven automations that trigger an agent to execute a task in the background. In IDE 1.0, creating them is as simple as describing what you want in plain English.
Structured v1 JSON Format
Hooks use a structured v1 JSON format stored in
.kiro/hooks/ with support for:- File event triggers:
PostFileSave,PostFileCreate,PostFileDelete
- Tool use interception:
PreToolUse,PostToolUse
- Spec task lifecycle:
PreTaskExec,PostTaskExec
- Session and prompt events:
SessionStart,UserPromptSubmit,Stop
Example: Lint on Save
{ "version": "v1", "hooks": [{ "name": "Lint on Save", "trigger": "PostFileSave", "matcher": "\\.(ts|tsx)$", "action": { "type": "command", "command": "npm run lint" } }]}
Example: Auto-Generate Tests After Task Completion
When a spec task finishes, automatically generate tests for the changed files:
{ "version": "v1", "hooks": [{ "name": "Generate Tests After Task", "trigger": "PostTaskExec", "action": { "type": "agent", "prompt": "Review the files that were just modified in this task. Generate unit tests for any new public functions or API endpoints that don't already have test coverage. Use the existing test patterns in the project." } }]}
Example: Security Gate on Write Operations
Block write operations to sensitive files unless they pass a review:
{ "version": "v1", "hooks": [{ "name": "Protect Config Files", "trigger": "PreToolUse", "matcher": "fs_write|str_replace", "action": { "type": "command", "command": "node scripts/check-sensitive-paths.js" } }]}
The
check-sensitive-paths.js script receives the tool call details on stdin and exits with code 2 (block) if the target path matches a protected pattern like *.env , terraform.tfstate , or secrets/ .Example: Auto-Update API Docs on Schema Change
{ "version": "v1", "hooks": [{ "name": "Regenerate API Docs", "trigger": "PostFileSave", "matcher": "openapi\\.ya?ml$|swagger\\.json$", "action": { "type": "command", "command": "npx @redocly/cli build-docs openapi.yaml --output docs/api.html" } }]}
Example: Add Context on Session Start
Inject project-specific context every time a new session begins:
{ "version": "v1", "hooks": [{ "name": "Load Project Context", "trigger": "SessionStart", "action": { "type": "agent", "prompt": "This project uses Next.js 15 with App Router, Prisma ORM with PostgreSQL, and Tailwind CSS v4. Auth is handled by NextAuth.js v5. Always check the prisma/schema.prisma file before writing database queries. Run 'npx prisma generate' after any schema changes." } }]}
Natural Language Creation Flow
Instead of writing JSON by hand, you can simply tell Kiro:
You: "Create a hook that runs our test suite whenever I save a file in the src/ directory, but only for .ts and .tsx files"
Kiro: I'll create that hook for you.→ Generates: .kiro/hooks/test-on-save.json
Migration from 0.x
Legacy hooks from Kiro 0.x can be migrated directly from the Agent Hooks panel. Manual hooks have been replaced by manual steering files — a cleaner separation of concerns.
Why It Matters
Hooks automate the repetitive tasks that experienced developers do manually — running tests after changes, updating docs when APIs shift, checking security after commits. Natural language creation removes the barrier to setting them up.
5. Dockable Chat Tabs
Open any chat session as a full-width editor tab.
For long conversations — spec reviews, architecture discussions, debugging sessions — the side panel can feel cramped. Dockable chat tabs give you the space you need.
How to Use
- Right-click a chat tab and select Open in Editor to dock it
- Split horizontally or vertically alongside source files
- Drag between editor groups
- Use a multi-monitor setup with chat on a separate screen
Stays in Sync
The editor tab and the chat panel stay in sync. Messages sent from either reach the same session. You're not creating a copy — you're just giving yourself a bigger viewport.
Example Workflow: Architecture Review with Docked Chat
Scenario: You're reviewing a database migration plan with the agent.
- Open the chat discussing the migration in a docked tab (right-click → Open in Editor)
- Split the editor vertically
- Open
prisma/schema.prismaon the left, docked chat on the right
- As the agent proposes schema changes, you see them as inline diffs in the chat while referencing the current schema side by side
Multi-Monitor Setup:
- Monitor 1: Full IDE with source files open
- Monitor 2: Docked chat tab showing the ongoing spec conversation
This lets you follow the agent's reasoning while reviewing the actual code impact in real time.
Why It Matters
Code reviews and architectural discussions often generate long conversation threads. Being able to view them alongside the code they reference, on a full-width tab or even a separate monitor, removes friction from the review process.
6. Session Export
Save any conversation as a portable archive.
Need to share a debugging session with a colleague, archive a spec discussion for documentation, or review an agent's work offline? Session export packages the full thread into a portable zip file.
What's Preserved
- All prompts and responses
- Tool calls and their outputs
- Code blocks and inline diffs
- The full conversation timeline
Example Use Cases
1. Onboarding Documentation:
You: "Explain how our payment processing pipeline works, starting from the Stripe webhook through to the order fulfillment service."
Agent: [detailed walkthrough of payment flow with code references]
→ Export session → Share with new team member as onboarding material
2. Incident Post-Mortem:
You: "Help me debug why the /api/users endpoint started returning 500 errors after yesterday's deploy."
Agent: [investigation across multiple files, identifies root cause, proposes fix]
→ Export session → Attach to incident ticket as investigation trail
3. Architecture Decision Record:
You: "Let's evaluate whether we should use SQS or EventBridge for our event-driven architecture. Consider our current scale of 10k events/sec."
Agent: [comparison analysis with pros/cons, cost estimates, code examples]
→ Export session → Add to /docs/adr/ as ADR-015-event-architecture.zip
The exported zip contains the complete thread — every prompt, every tool call, every code block — so anyone reviewing it later gets the full context of how a decision was reached.
Why It Matters
AI-assisted development sessions often contain valuable institutional knowledge — debugging approaches, architectural decisions, exploratory work. Export makes that knowledge portable, shareable, and archivable rather than locked inside a single IDE instance.
7. Inline Agent Switching
Switch agents mid-conversation without losing context.
The agent selector sits in the chat input bar alongside the model picker. You can move from the Default agent to a custom code reviewer to Spec mode all within a single conversation.
How It Works
- Select a different agent from the dropdown in the chat input bar
- Conversation history is preserved across switches
- Each agent brings its own tool access, permissions, and personality
- Set a preferred default that persists across restarts
Example: A Real Development Workflow with Agent Switching
Here's how inline switching plays out during a typical feature build:
Step 1: Start in Default agent (Vibe mode)─────────────────────────────────────────You: "I need to add rate limiting to our API. What are the options for Express.js? Consider our Redis setup."
Agent: [explores options, discusses express-rate-limit vs custom middleware vs API Gateway approach]
Step 2: Switch to Security Reviewer agent─────────────────────────────────────────You: [switch agent → Security Reviewer]You: "Given the approach we just discussed, are there any security concerns with the Redis-backed rate limiter?"
Agent: [reviews for race conditions, key enumeration, bypass vectors]
Step 3: Switch to Spec mode───────────────────────────You: [switch agent → Spec]You: "Let's formalize this into a spec. Rate limiting with Redis, sliding window algorithm, per-user and per-IP limits."
Agent: [generates requirements.md, design.md, tasks.md]
Step 4: Switch to Terraform Architect agent───────────────────────────────────────────You: [switch agent → Terraform Architect]You: "We need a Redis ElastiCache cluster for the rate limiter. Single-node for dev, 3-node for prod."
Agent: [writes elasticache.tf with proper security groups and parameter groups]
The full conversation history is preserved across all four switches. Each agent contributes its specialty without you losing the thread.
Why It Matters
Real development workflows don't fit neatly into a single agent profile. You might start exploring a problem in Vibe mode, switch to a security-focused agent to audit your approach, then move to Spec mode to formalize the implementation. Inline switching makes this natural rather than disruptive.
Putting It All Together: A Complete Blueprint
Here's how all these features work together in a real project setup:
Project: E-Commerce Platform
Directory structure:
my-ecommerce/├── .kiro/│ ├── agents/│ │ ├── code-reviewer.md # Reviews PRs for bugs and style│ │ ├── api-developer.md # Builds REST/GraphQL endpoints│ │ ├── frontend-dev.md # React/Next.js specialist│ │ └── devops.md # Infrastructure and CI/CD│ ├── hooks/│ │ ├── lint-on-save.json # Runs ESLint on save│ │ ├── test-on-task.json # Runs tests after spec tasks│ │ ├── security-gate.json # Blocks writes to sensitive files│ │ └── api-docs.json # Regenerates OpenAPI docs on change│ └── steering/│ ├── project-standards.md # Coding standards (always included)│ ├── api-patterns.md # REST conventions (on file match)│ └── database-rules.md # Query patterns (manual inclusion)├── src/├── infra/└── docs/
Workflow:
- Open Agent Focus → Launch 3 parallel sessions for frontend, backend, and infra
- Permissions ensure the frontend agent can't touch infra files, and the devops agent can't modify source code
- Custom agents bring specialized context — the API developer knows your REST conventions, the devops agent knows your Terraform modules
- Hooks run linting, tests, and security checks automatically as work progresses
- Dockable chat lets you review the spec discussion on one monitor while coding on another
- Session export captures the architectural decisions for your team wiki
- Inline switching lets you bring in the security reviewer mid-conversation when you hit a sensitive area
Getting Started with Kiro IDE 1.0
To get the latest 1.0.x release (1.0.52 or later), download it directly from kiro.dev/downloads . Once installed:
- Agent Focus shows up in the top-right corner of the window
- Permissions start working immediately with sensible defaults
- Custom agents appear the moment you save a Markdown file to
.kiro/agents/
- Hooks can be created from the Agent Hooks panel or via natural language
- Dockable chat is available via right-click on any chat tab
- Session export is accessible from the session menu
The Bigger Picture
Kiro IDE 1.0 is part of a broader evolution in how developers interact with AI. The release reflects a fundamental insight: as AI agents become more capable, the developer's role shifts from writing every line to directing, reviewing, and verifying work. The features in this release — permissions for safety, custom agents for specialization, Agent Focus for orchestration — are all designed to support that shift without sacrificing control.
Whether you're a solo developer looking for a more structured AI workflow or a team looking to standardize agent usage across your organization, Kiro IDE 1.0 provides the tools to work with AI agents confidently and productively.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article