ai-engineer

AI Engineer kit for building production chatbots and agents on AWS with 20 agents, 37 skills, 70 commands — Amazon Bedrock AgentCore (Runtime, Gateway, Memory), MCP server hosting, Strands Agents, Bedrock Knowledge Bases RAG, guardrails, and agent evaluation

npx kiro-kit add ai-engineer

At a glance

Artifact	Count
Commands	70
Agents	20
Skills	37
Workflows	4
Hook scripts	9
Native Kiro hooks	7
Files written in total	342

Category: ai-engineer · Version: 1.0.0

Tags: ai-agents, chatbot, mcp, bedrock, agentcore, strands, rag, llm, evaluation, aws

Commands

Command	Description
`ask`	⚡ Answer technical and architectural questions.
`bootstrap`	Bootstrap the data/ML project with Python environment and dependencies
`bootstrap/auto`	⚡⚡⚡⚡ Bootstrap a new project automatically
`bootstrap/auto/fast`	⚡⚡⚡ Quickly bootstrap a new project automatically
`brainstorm`	⚡⚡ Brainstorm a feature
`clean`	Clean build artifacts, caches, and temporary files from the project
`code`	⚡ Start coding & testing an existing plan
`content/cro`	Analyze the current content and optimize for conversion
`content/enhance`	Analyze the current copy issues and enhance it
`content/fast`	Write creative & smart copy [FAST]
`content/good`	Write good creative & smart copy [GOOD]
`cook`	⚡⚡⚡ Implement a feature [step by step]
`cook/auto`	⚡⚡ Implement a feature automatically ("trust me bro")
`cook/auto/fast`	⚡ No research. Only scout, plan & implement ["trust me bro"]
`data/clean`	Clean a dataset by handling missing values, duplicates, and type issues
`data/explore`	Explore a dataset with automated EDA (shape, types, distributions, missing values)
`data/profile`	Generate a comprehensive data profiling report
`data/validate`	Validate data quality using schema checks and expectations
`debug`	⚡⚡ Debugging technical issues and providing solutions.
`docs/architecture`	Generate or update system architecture documentation
`docs/init`	⚡⚡⚡⚡ Analyze the codebase and create initial documentation
`docs/summarize`	Analyze the codebase and generate documentation summary
`docs/update`	Update project documentation based on recent code changes
`fix`	⚡⚡ Analyze and fix small issues [AUTO DETECT COMPLEXITY]
`fix/build`	Diagnose and fix build or dependency issues
`fix/ci`	⚡ Analyze Github Actions logs and fix issues
`fix/fast`	⚡ Analyze and fix small issues [FAST]
`fix/hard`	⚡⚡⚡ Use subagents to plan and fix hard issues
`fix/lint`	Auto-fix linting issues in Python code
`fix/logs`	⚡ Analyze logs and fix issues
`fix/test`	⚡⚡ Run test suite and fix issues
`fix/tests`	Diagnose and fix failing tests
`fix/types`	⚡ Fix type errors
`fix/ui`	⚡⚡ Analyze and fix UI issues
`git/branch`	Create a new feature branch with naming convention
`git/cm`	Stage all files and create a commit.
`git/commit`	Create a conventional commit with staged changes
`git/cp`	Stage, commit and push all code in the current branch
`git/pr`	Create a pull request with conventional format
`journal`	⚡ Write some journal entries.
`lint`	Run linting and type checking on Python codebase
`ml/compare`	Compare multiple model runs or experiments side by side
`ml/deploy`	Deploy a trained model to a serving endpoint
`ml/evaluate`	Evaluate a trained model on test data with comprehensive metrics
`ml/train`	Train a machine learning model with experiment tracking
`ml/tune`	Run hyperparameter tuning with Optuna or grid search
`pipeline/build`	Build a data pipeline DAG from configuration
`pipeline/run`	Execute a data pipeline locally or trigger remote execution
`pipeline/validate`	Validate pipeline configuration and data contracts
`plan`	⚡⚡⚡ Intelligent plan creation with prompt enhancement
`plan/ci`	Analyze Github Actions logs and provide a plan to fix the issues
`plan/cro`	Create a CRO plan for the given content
`plan/fast`	⚡⚡ No research. Only analyze and create an implementation plan
`plan/feature`	Plan a new data/ML feature with research and task breakdown
`plan/hard`	⚡⚡⚡ Research, analyze, and create an implementation plan
`plan/refactor`	Plan a refactoring effort with impact analysis
`plan/two`	⚡⚡⚡⚡ Research & create an implementation plan with 2 approaches
`release`	Prepare a release with version bump, changelog, and package build
`review/code`	Review code changes for correctness, performance, and best practices
`review/codebase`	⚡⚡⚡ Scan & analyze the codebase.
`review/security`	Security review focused on data handling and credentials
`scout`	Scout the codebase to find relevant files for a task
`scout/ext`	Scout codebase using external agentic tools (Gemini, OpenCode)
`skill/add`	Add a new skill to the agent ecosystem
`skill/create`	Create a new skill from scratch with guided workflow
`skill/fix-logs`	Fix the agent skill based on `logs.txt` file.
`skill/optimize`	Optimize an existing skill for better activation and token efficiency
`test`	Run test suite with coverage reporting
`use-mcp`	Utilize tools of Model Context Protocol (MCP) servers
`watzup`	⚡ Review recent changes and wrap up the work

Agents

Agent	Description
`brainstormer`	Use when you need to brainstorm software solutions, evaluate architectural approaches, or debate technical decisions before implementation begins.
`code-reviewer`	Use when you need code review, quality analysis, or feedback on Python/ML implementations including data pipelines, model code, and notebook quality.
`copywriter`	Use when you need high-converting copy for marketing materials, social media posts, landing pages, email campaigns, or any content that must capture attention and drive action.
`data-pipeline-architect`	Use when you need to design ETL/ELT pipelines, data orchestration workflows, streaming architectures, or data platform infrastructure.
`data-scientist`	Use when you need exploratory data analysis, statistical modeling, feature engineering, hypothesis testing, or data visualization for ML projects.
`database-admin`	Use when you need database diagnostics, query optimization, schema design, index strategy, backup planning, replication setup, or performance troubleshooting.
`debugger`	Use when you need to investigate issues, diagnose errors, analyze logs, trace execution flows, identify performance bottlenecks, or troubleshoot failing tests and deployments.
`docs-manager`	Use when you need to create, update, or organize technical documentation, synchronize docs with code changes, write product requirements, or maintain documentation standards.
`git-manager`	Use when you need to stage, commit, push code changes, create pull requests, or manage git operations with conventional commit messages.
`journal-writer`	Use when significant technical difficulties occur -- repeated test failures, critical bugs, failed refactoring, security vulnerabilities, or architectural decisions that prove problematic in practice.
`mcp-manager`	Use when you need to manage MCP (Model Context Protocol) server integrations, discover available tools and resources, execute MCP capabilities, or troubleshoot MCP connectivity issues.
`ml-engineer`	Use when you need to train models, optimize hyperparameters, implement training pipelines, deploy models to production, or debug model performance issues.
`model-evaluator`	Use when you need model validation, performance benchmarking, bias detection, fairness auditing, or A/B test analysis for ML models.
`planner`	Use when you need to research, analyze, and create comprehensive implementation plans for features, system architectures, or complex technical solutions before starting implementation.
`project-manager`	Use when you need project oversight, progress tracking against implementation plans, status reporting, milestone management, or coordination across multiple workstreams.
`researcher`	Use when you need to research technologies, find documentation, explore best practices, evaluate libraries, or gather technical information from multiple sources before making decisions.
`scout`	Use when you need to quickly locate relevant files across a large codebase for a specific task, before starting implementation or debugging that spans multiple directories.
`scout-external`	Use when you need to locate files across a large codebase using external agentic tools (Gemini, OpenCode) for faster parallel searching with large context windows.
`tester`	Use when you need to validate code through testing -- running test suites, analyzing coverage, checking for regressions, validating error handling, or verifying build processes after implementation changes.
`ui-ux-designer`	Use when you need UI/UX design work including interface designs, wireframes, design systems, responsive layouts, accessibility audits, or design documentation and review.

Skills

Skill	Description
`agent-evaluation`	Build evaluation harnesses for agents and chatbots — golden sets, deterministic tool-selection checks, LLM-as-a-Judge, Bedrock RAG evaluation jobs, CI gates, and online drift monitoring. Use when an agent needs a quality gate before merge or a quality alarm in production.
`agentcore-gateway-mcp`	Turn Lambda functions, OpenAPI and Smithy APIs, and existing MCP servers into a unified MCP tool surface with Amazon Bedrock AgentCore Gateway. Use when giving an agent tools, configuring inbound or outbound Gateway auth, or enabling semantic tool discovery at scale.
`ai-multimodal`	Process and generate multimedia content using Google Gemini API. Use when analyzing images, processing documents, transcribing audio, or generating visual content for data science workflows.
`bedrock-agentcore`	Deploy and operate agents on Amazon Bedrock AgentCore — Runtime, Harness, Memory, Identity, and Observability. Use when hosting an agent on AWS, containerising an agent for AgentCore Runtime, wiring session or long-term memory, or choosing between Harness, Runtime, and plain Lambda.
`bedrock-rag`	Build RAG on Amazon Bedrock Knowledge Bases — ingestion, chunking, embeddings, vector stores, Retrieve and RetrieveAndGenerate, citations, and Guardrails contextual grounding. Use when a chatbot must answer from a document corpus with sources.
`code-review`	Review data science and ML code for correctness, performance, and best practices. Use when receiving feedback, completing features, or before merging.
`data-engineering`	Design and implement data pipelines, ETL processes, and data infrastructure. Use when building data ingestion, transformation, or storage systems.
`data-visualization`	Create effective data visualizations with matplotlib, seaborn, and plotly. Use when building charts, dashboards, or communicating data insights visually.
`databases`	Work with MongoDB (document database, BSON documents, aggregation pipelines, Atlas cloud) and PostgreSQL (relational database, SQL queries, psql CLI, pgAdmin). Use when designing database schemas, writing queries and aggregations, optimizing indexes for performance, performing database migrations, configuring replication and sharding, implementing backup and restore strategies, managing database users and permissions, analyzing query performance, or administering production databases.
`debugging`	Systematic debugging framework for data and ML code. Use when encountering bugs, test failures, unexpected model behavior, or data quality issues.
`docs-seeker`	Search and retrieve technical documentation for data science libraries and ML frameworks. Use when you need to find API references, usage examples, or migration guides.
`document-skills-docx`	Process and generate Word documents (DOCX) programmatically. Use when creating reports, extracting text from documents, or automating document generation in data pipelines.
`document-skills-pdf`	Extract and process PDF documents for data pipelines. Use when parsing research papers, extracting tables from reports, or converting PDFs to structured data.
`document-skills-pptx`	Process and generate PowerPoint presentations programmatically. Use when creating data presentations, extracting content from slides, or automating report generation.
`document-skills-xlsx`	Process and generate Excel spreadsheets programmatically. Use when reading data from Excel files, creating formatted reports, or building data export pipelines.
`experiment-tracking`	Track ML experiments systematically with MLflow, W&B, or similar tools. Use when running experiments, comparing model versions, or managing reproducibility.
`feature-store`	Design and manage feature stores for ML systems. Use when building reusable feature pipelines, managing feature versioning, or serving features for inference.
`google-adk-python`	Build AI agents with Google Agent Development Kit (ADK) for Python. Use when creating multi-agent systems, tool-using agents, or orchestrating LLM workflows with Google Cloud.
`jupyter-notebooks`	Work effectively with Jupyter notebooks for data exploration and analysis. Use when creating notebooks, converting formats, or establishing notebook best practices.
`mcp-builder`	Build MCP (Model Context Protocol) servers for data and ML tool integration. Use when creating custom tool servers for database access, model inference, or data processing.
`mcp-management`	Manage MCP server configurations and tool discovery. Use when configuring data tool servers, discovering available capabilities, or troubleshooting MCP connections.
`mcp-server-hosting`	Build and host a remote MCP server on AWS — Lambda, Fargate/ECS, or AgentCore Runtime — with OAuth via Cognito, Okta, or Auth0 and the RFC 7235 401 + WWW-Authenticate handshake. Use when deploying an MCP server for remote agents rather than local stdio use.
`media-processing`	Process multimedia files with FFmpeg (video/audio encoding, conversion, streaming, filtering, hardware acceleration) and ImageMagick (image manipulation, format conversion, batch processing, effects, composition). Use when converting media formats, encoding videos with specific codecs (H.264, H.265, VP9), resizing/cropping images, extracting audio from video, applying filters and effects, optimizing file sizes, creating streaming manifests (HLS/DASH), generating thumbnails, batch processing images, creating composite images, or implementing media processing pipelines. Supports 100+ formats, hardware acceleration (NVENC, QSV), and complex filtergraphs.
`ml-ops`	Deploy, monitor, and manage ML models in production. Use when setting up model serving, experiment tracking, or ML infrastructure.
`nlp-text-processing`	Process and analyze text data with NLP techniques. Use when building text classification, NER, sentiment analysis, or text preprocessing pipelines.
`pandas-analysis`	Data manipulation and analysis with pandas. Use when cleaning data, performing aggregations, merging datasets, or building analysis pipelines.
`planning`	Plan technical solutions for data science and ML projects. Use when designing experiments, architecting pipelines, or scoping ML features.
`problem-solving`	Apply systematic problem-solving techniques for data science and ML challenges. Use when stuck on complexity, innovation blocks, or recurring patterns.
`pytorch-training`	Train and optimize deep learning models with PyTorch. Use when building neural networks, implementing training loops, or optimizing model performance.
`repomix`	Package code repositories into single AI-friendly files for analysis. Use when you need to understand a codebase structure or prepare context for analysis.
`research`	Research and analyze technical solutions, ML libraries, and data science best practices. Use when evaluating models, finding documentation, or investigating unfamiliar algorithms.
`scikit-learn`	Classical machine learning with scikit-learn. Use when building classification, regression, clustering models, or implementing feature engineering pipelines.
`sequential-thinking`	Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis and revision. Use for complex decomposition or when you need to think step by step.
`skill-creator`	Guide for creating effective agent skills. Use when building new skills to extend agent capabilities with specialized knowledge.
`strands-agents`	Build agents with the Strands Agents SDK — the model-driven tool loop, custom tools, MCP clients, multi-agent patterns, streaming, and observability hooks. Use when writing agent code for this workspace, which defaults to Strands with Amazon Bedrock as the model provider.
`template-skill`	Template for creating new data/ML skills. Copy this folder and customize for your domain.
`tensorflow-keras`	Build and train models with TensorFlow and Keras. Use when implementing production ML models, using tf.data pipelines, or deploying with TF Serving.

Workflows

Workflow
`development-rules`
`documentation-management`
`orchestration-protocol`
`primary-workflow`

Hooks

Registered in settings.json:

Event	Hook
`PreToolUse`	`scout-block`
`PostToolUse`	`modularization-hook`
`agentStop`	`discord-notify`
`agentStop`	`telegram-notify`

Hook scripts shipped with this preset:

Script
`data-drift-check`
`discord-notify`
`experiment-log`
`git-status-tracker`
`model-card-update`
`modularization-hook`
`pre-commit-lint`
`scout-block`
`telegram-notify`

Native Kiro Agent Hooks (ship disabled; enable them in Kiro's Agent Hooks panel):

Native hook
`agent-card-update`
`docs-drift-guard`
`prompt-change-eval`
`run-tests-on-save`
`secret-scan-on-save`
`spec-task-sync`
`tool-contract-check`

MCP servers

Server
`fetch`
`filesystem`
`git`

Kiro Powers

Recommended Kiro Powers for this preset. init auto-wires the credential-free MCP-backed ones and scaffolds the credentialed ones disabled.

Tier	Power	Description	Auth	MCP-backed
`essential`	AWS Infrastructure as Code	CDK and CloudFormation for AgentCore, Lambda, and Bedrock Knowledge Base resources	`none`	no
`essential`	Terraform	Provision AgentCore Runtime/Gateway, MCP servers, and Bedrock resources as code	`none`	no
`recommended`	Context7	Up-to-date SDK documentation lookup (Strands, MCP, Bedrock, LangGraph)	`none`	yes
`recommended`	Exa	Neural web search for grounding designs against fast-moving AWS documentation	`apiKey`	no
`recommended`	Hugging Face	Open models, datasets, and inference endpoints for non-Bedrock providers	`apiKey`	no
`optional`	Datadog	Production observability for agent latency, token cost, and error budgets	`apiKey`	no
`optional`	Langfuse	Open-source tracing, evaluation, and prompt management for LLM agents	`apiKey`	no
`optional`	LangSmith	Tracing, evals, and monitoring for LLM and agent applications	`apiKey`	no
`optional`	Pinecone	Managed vector database when a Bedrock Knowledge Base vector store is not the fit	`apiKey`	no
`optional`	Snyk	Dependency and container scanning for agent runtime images	`apiKey`	no

Example specs

Fully-written requirements.md / design.md / tasks.md trios you can read as worked examples.

Spec
AgentCore Support Chatbot
MCP Server On Lambda
Multi Agent Orchestrator
RAG Knowledge Assistant

On this page