Intent vs Kiro (2026): Living Specs vs AWS-Native Development

Intent is the stronger spec-driven development tool for teams managing complex, multi-service codebases because living specs, multi-agent orchestration, and BYOA model flexibility address the core failure mode of specification-driven workflows: specs that drift from reality the moment code changes. Kiro brings structured EARS notation requirements and deep AWS service integration through Amazon Bedrock, making it well-suited for greenfield projects within AWS-committed organizations.

Two Spec-Driven Tools, Two Different Philosophies

Spec-driven development emerged as the dominant methodology for professional teams shipping production software with AI agents in 2025-2026. The premise is straightforward: define what you want built in a structured specification before agents write code, reducing the "vibe coding" problem where AI generates plausible but architecturally incoherent output.

Both Intent and Kiro implement this methodology, but they diverge sharply in how specifications live, how agents execute, and how much infrastructure lock-in teams accept. After testing both tools on real development workflows, the differences become obvious once tasks exceed single-file complexity.

Intent, built by Augment Code, is a standalone desktop workspace for orchestrating agents over isolated git worktrees. Inside Intent, you choose a CLI agent. Augment's own Auggie provides full Context Engine features and workflow integrations, while third-party agents such as Claude Code, Codex, or OpenCode work with fewer built-in features. Specs function as bidirectional documents that both humans and agents read from and write to. Kiro, built by AWS, is a Code OSS-based IDE that uses EARS notation for structured requirements and a primary agent enhanced by hooks automation, running on Amazon Bedrock infrastructure.

This comparison breaks down five critical dimensions where these tools make fundamentally different architectural choices.

Living Specs vs EARS Notation: How Specifications Stay Current

The central challenge of spec-driven development is keeping specifications synchronized with code. Both tools attempt to solve this problem, but through architecturally different mechanisms.

Intent: Self-Updating Living Specifications

Intent implements living specs as bidirectional documents: self-maintaining summaries of project goals, requirements, completed work, outstanding tasks, and the assumptions and trade-offs behind each decision.

All agents share read access to the same spec document. When an agent completes a task, it writes the results back atomically, and those changes propagate to every other active agent automatically.

In testing, the Coordinator analyzed the codebase context, drafted a spec, and generated tasks for specialized agents. As agents completed work, the spec was updated to reflect what actually happened. When requirements changed mid-task, updates propagated to all active agents without manual intervention.

This approach directly addresses the core cost of spec-driven workflows: keeping a written artifact synchronized with a changing system requires continuous effort, and engineers tend to work in bursts rather than maintaining documents incrementally. Intent solves this by making the spec a shared artifact that both humans and agents read from and write to, so neither side bears the full synchronization burden.

Kiro: EARS Notation With Manual Synchronization

Kiro implements the EARS notation developed by Rolls-Royce, following the pattern: WHEN [condition/event] THE SYSTEM SHALL [expected behavior]. Kiro supports two workflow variants, requirements-first and design-first, documented in its official feature-spec workflow.

EARS notation reduces ambiguity while staying readable for humans, and the underlying method has published industrial validation in requirements engineering literature with an official reference maintained by its creator. Kiro also generates property-based tests by extracting testable properties from EARS requirements.

The limitation surfaces during iteration: EARS specs remain point-in-time snapshots requiring manual synchronization.

Additionally, Kiro's feature-spec workflow is inherently structured around producing requirements/design/tasks artifacts, with the two supported sequences defined in the docs, which can add overhead to small changes. Martin Fowler notes that this structure can feel heavy for small fixes, where multiple user stories and numerous acceptance criteria might be generated even for a tiny bug fix.

Multi-Agent Orchestration vs Single Agent With Hooks

The agent architecture is where Intent and Kiro make their most consequential divergence: coordinated specialists versus a primary agent enhanced by automation hooks.

Intent: Coordinator, Specialist, and Verifier Agents

Intent implements a three-tier orchestration architecture. The Coordinator agent analyzes prompts using Augment Code's Context Engine, which indexes entire codebases across 400,000+ files through semantic dependency graph analysis. The Coordinator breaks specifications into executable tasks and delegates to specialist agent roles such as Investigate, Implement, Verify, Critique, Debug, and Code Review.

Multiple agents execute in parallel, each in their own context. The Coordinator keeps everything aligned and handles handoffs. When agents finish, a Verifier agent checks results against the spec to flag inconsistencies, bugs, or missing pieces before handing work back for human review.

Testing this architecture on multi-file refactoring tasks reveals the value of the separation of concerns. The Investigate agent explores feasibility while the Implement agent executes the plan, and the Verifier catches inconsistencies that neither would have flagged independently.

The trade-off is real: platform guidance from Azure and Google Cloud notes that multi-agent systems often add latency due to coordination overhead and increase cost through additional model calls relative to single-agent flows. Intent mitigates this through parallel execution across isolated worktrees. Debugging distributed agent interactions also requires more sophisticated observability.

Kiro: Primary Agent With Hook-Based Automation

Kiro uses a primary agent with hook-based automation rather than a visible multi-agent system. Hooks act as automated triggers for quality or workflow checks at specific checkpoints. Hooks can be stored as hook definition files (for example, under a .kiro/hooks directory with a .kiro.hook extension) and can execute either AI-powered agent prompts or non-AI shell commands when triggered.

BYOA Flexibility vs Amazon Bedrock Lock-In

Model flexibility determines how much control teams retain over cost, performance, and vendor dependency.

Intent: Bring Your Own Agent

Intent supports multiple agent providers, including Claude Code, Codex, and OpenCode, alongside Augment’s own Auggie agent. Teams with existing AI subscriptions can plug those agents into Intent so model usage is billed to those providers, but Intent still runs on an Augment Code account. Per-task model selection means different tasks can use different models (e.g., higher-end Claude or OpenAI models for architectural planning and smaller models for quick edits), depending on what your connected agents support.

Full Model Context Protocol (MCP) support connects external tools, databases, documentation, and APIs. Non-Augment agents can integrate with Augment Code's Context Engine via MCP for enhanced semantic understanding of large codebases.

This flexibility matters for enterprise teams managing AI costs across multiple projects. Testing Intent with an existing Claude Code subscription confirmed that the full workspace experience works with model usage billed through the existing provider.

Kiro: Amazon Bedrock Infrastructure

Kiro accesses models through AWS infrastructure, offering three primary model tiers (Haiku, Sonnet, and Opus) plus an Auto mode that uses smart routing.

Kiro integrates deeply with AWS services (Lambda, CDK, CloudFormation, CodeCatalyst), and agents built on this infrastructure become tightly coupled to AWS patterns. For AWS-centric organizations, this integration is a strength. For multi-cloud teams, the infrastructure dependency creates migration complexity and limits model experimentation with providers outside the Bedrock ecosystem.

Kiro's pricing operates on a credit-based consumption model across four tiers:

Kiro currently offers 500 bonus credits for new users, usable within 30 days. Both spec requests and vibe requests consume credits, with different overage rates explained in Kiro's official pricing breakdown.

Isolated Git Worktrees vs Single-Project Context

How each tool manages the filesystem during agent execution directly impacts parallel development capability and context isolation.

Intent: Isolated Git Worktrees per Agent

Intent automatically creates a Space with a dedicated git branch and worktree for each prompt. Each worktree maintains a separate working-directory state (e.g., HEAD and index) while sharing the underlying repository history and object database, consistent with how Git worktrees operate.

The worktree organization follows a sibling directory pattern:

~/code/myproject/              ← main repository
~/code/myproject-feature-a/    ← worktree for Space A
~/code/myproject-feature-b/    ← worktree for Space B

Agents build, test, and modify code without conflicts until explicitly merged. Worktree creation uses hard links on Linux, making creation fast. Resumable sessions persist worktree state, conversation history, specification evolution, and task completion status across sessions.

Kiro: Single-Project Context

Kiro operates within a single-project context through its Code OSS-based IDE. While Kiro supports branching through standard git commands, agent execution occurs within the active project context rather than per-prompt isolated worktrees.

Kiro supports "steering"/configuration documents to shape agent behavior, but these manage instruction and scope, not filesystem isolation. As workflows grow, context selection and conversation management become important: as Martin Fowler notes from tool evaluations, large context windows alone don't guarantee the agent will reliably pick up the right constraints.

Enterprise Security: SOC 2 Type II + ISO 42001 vs AWS Shared Responsibility

For enterprise procurement, security certification determines whether a tool passes vendor evaluation.

Augment Code, the platform powering Intent, holds SOC 2 Type II certification (validating security control effectiveness over a minimum of six consecutive months, per the SOC framework definition) plus ISO/IEC 42001 certification, which specifies requirements for AI-specific management systems, including AI lifecycle governance, algorithmic accountability, and human oversight requirements.

Kiro operates under AWS's shared responsibility model, where AWS manages infrastructure security (host OS, virtualization, physical security) while customers assume responsibility for application-layer security, data protection, and IAM policy management. AWS provides SOC 2 Type II compliance for its infrastructure layer, and Kiro offers GovCloud availability (with IAM Identity Center support) per its official billing and platform documentation.

SOC 2 Type II + ISO 42001 certification creates vendor-owned, third-party validated security commitments, while AWS shared responsibility distributes AI-specific governance to customers. Deloitte research found that while 87% of executives claim to have AI governance frameworks, fewer than 25% have fully operationalized enterprise governance. That 62% gap makes the shared responsibility burden significant for many organizations.

For organizations in regulated industries lacking mature AI security capabilities, vendor-certified compliance reduces the due diligence burden.

Match the Tool to the Codebase

The Intent vs Kiro decision comes down to where each tool's architecture meets your actual constraints. Kiro fits teams already committed to AWS infrastructure who need structured EARS notation for compliance traceability on greenfield projects, particularly in regulated environments pursuing GovCloud-aligned deployments. Intent fits teams managing complex, multi-service codebases where specifications must evolve with the code, multiple agents need to work in parallel, and model flexibility matters more than infrastructure integration.

FAQ

Related

• Intent vs Devin
• Augment Code vs Kiro
• Kiro vs Qodo
• Best Tools for SDD
• Augment Code vs Windsurf