Coding Agent

Coding Agent (bash-first)

Use bash (with optional background mode) for all coding agent work. Simple and effective.

⚠️ PTY Mode Required!

Coding agents (Codex, Claude Code, Kiro, Pi) are interactive terminal applications that need a pseudo-terminal (PTY) to work correctly. Without PTY, you'll get broken output, missing colors, or the agent may hang.

Always use pty:true when running coding agents:

# ✅ Correct - with PTY
bash pty:true command:"codex exec 'Your prompt'"

# ❌ Wrong - no PTY, agent may break
bash command:"codex exec 'Your prompt'"

Bash Tool Parameters

Process Tool Actions (for background sessions)

Quick Start: One-Shot Tasks

For quick prompts/chats, create a temp git repo and run:

# Quick chat (Codex needs a git repo!)
SCRATCH=$(mktemp -d) && cd $SCRATCH && git init && codex exec "Your prompt here"

# Or in a real project - with PTY!
bash pty:true workdir:~/Projects/myproject command:"codex exec 'Add error handling to the API calls'"

Why git init? Codex refuses to run outside a trusted git directory. Creating a temp repo solves this for scratch work.

The Pattern: workdir + background + pty

For longer tasks, use background mode with PTY:

# Start agent in target directory (with PTY!)
bash pty:true workdir:~/project background:true command:"codex exec --full-auto 'Build a snake game'"
# Returns sessionId for tracking

# Monitor progress
process action:log sessionId:XXX

# Check if done
process action:poll sessionId:XXX

# Send input (if agent asks a question)
process action:write sessionId:XXX data:"y"

# Submit with Enter (like typing "yes" and pressing Enter)
process action:submit sessionId:XXX data:"yes"

# Kill if needed
process action:kill sessionId:XXX

Why workdir matters: Agent wakes up in a focused directory, doesn't wander off reading unrelated files (like your soul.md 😅).

Codex CLI

Model: gpt-5.2-codex is the default (set in ~/.codex/config.toml)

Flags

Building/Creating

# Quick one-shot (auto-approves) - remember PTY!
bash pty:true workdir:~/project command:"codex exec --full-auto 'Build a dark mode toggle'"

# Background for longer work
bash pty:true workdir:~/project background:true command:"codex --yolo 'Refactor the auth module'"

Reviewing PRs

⚠️ CRITICAL: Never review PRs in OpenClaw's own project folder! Clone to temp folder or use git worktree.

# Clone to temp for safe review
REVIEW_DIR=$(mktemp -d)
git clone https://github.com/user/repo.git $REVIEW_DIR
cd $REVIEW_DIR && gh pr checkout 130
bash pty:true workdir:$REVIEW_DIR command:"codex review --base origin/main"
# Clean up after: trash $REVIEW_DIR

# Or use git worktree (keeps main intact)
git worktree add /tmp/pr-130-review pr-130-branch
bash pty:true workdir:/tmp/pr-130-review command:"codex review --base main"

Batch PR Reviews (parallel army!)

# Fetch all PR refs first
git fetch origin '+refs/pull/*/head:refs/remotes/origin/pr/*'

# Deploy the army - one Codex per PR (all with PTY!)
bash pty:true workdir:~/project background:true command:"codex exec 'Review PR #86. git diff origin/main...origin/pr/86'"
bash pty:true workdir:~/project background:true command:"codex exec 'Review PR #87. git diff origin/main...origin/pr/87'"

# Monitor all
process action:list

# Post results to GitHub
gh pr comment <PR#> --body "<review content>"

Claude Code

# With PTY for proper terminal output
bash pty:true workdir:~/project command:"claude 'Your task'"

# Background
bash pty:true workdir:~/project background:true command:"claude 'Your task'"

Kiro CLI (AWS)

AWS AI coding assistant with session persistence, custom agents, steering, and MCP integration.

Installation

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

# Linux AppImage (portable, no install needed)
wget https://desktop-release.q.us-east-1.amazonaws.com/latest/kiro-cli.appimage
chmod +x kiro-cli.appimage && ./kiro-cli.appimage

# Ubuntu (.deb)
wget https://desktop-release.q.us-east-1.amazonaws.com/latest/kiro-cli.deb
sudo dpkg -i kiro-cli.deb && sudo apt-get install -f

# Linux zip (check glibc version first: ldd --version)
# Use standard version for glibc >= 2.34, musl version for older
curl --proto '=https' --tlsv1.2 -sSf 'https://desktop-release.q.us-east-1.amazonaws.com/latest/kirocli-x86_64-linux.zip' -o 'kirocli.zip'
unzip kirocli.zip && ./kirocli/install.sh

Proxy (enterprise, v1.8.0+): Set HTTP_PROXY, HTTPS_PROXY, NO_PROXY environment variables.

Authentication

Supports GitHub, Google, AWS Builder ID, and IAM Identity Center.

kiro-cli login      # Sign in (prompts automatically on first use)
kiro-cli logout     # Sign out
kiro-cli whoami     # Check current user
kiro-cli doctor     # Diagnose issues

Remote login (SSH): Builder ID/IAM uses device code (no setup needed). For social login (Google/GitHub), use SSH port forwarding:

# 1. Run kiro-cli login on remote, note the port (e.g., 49153)
# 2. On local machine: ssh -L 49153:localhost:49153 -N user@remote-host
# 3. Press Enter on remote, complete auth in local browser

Basic Usage

kiro-cli                           # Start interactive chat (default)
kiro-cli chat "Your question"      # Direct question
kiro-cli --agent my-agent          # Use specific agent
kiro-cli chat --resume             # Resume last session (per-directory)
kiro-cli chat --resume-picker      # Pick from saved sessions
kiro-cli chat --list-sessions      # List all sessions

Non-Interactive Mode (scripting/automation)

# Single response to STDOUT, then exit
kiro-cli chat --no-interactive "Show current directory"

# Trust all tools (no confirmation prompts)
kiro-cli chat --no-interactive --trust-all-tools "Create hello.py"

# Trust specific tools only (comma-separated)
kiro-cli chat --no-interactive --trust-tools "fs_read,fs_write" "Read package.json"

🔐 Tool Trust: Use --trust-all-tools for automation (default). For untrusted input or sensitive systems, consider --trust-tools "fs_read,fs_write,shell" to limit scope.

OpenClaw Integration

# Interactive session (background)
bash pty:true workdir:~/project background:true command:"kiro-cli"

# One-shot query (non-interactive)
bash pty:true workdir:~/project command:"kiro-cli chat --no-interactive --trust-all-tools 'List all TODO comments in src/'"

# With specific agent
bash pty:true workdir:~/project background:true command:"kiro-cli --agent aws-expert 'Set up Lambda'"

# Resume previous session
bash pty:true workdir:~/project command:"kiro-cli chat --resume"

Key Arguments

In-Chat Commands

Multi-line input: Press Ctrl+J to insert newline, or use /editor.

Custom Agents

Pre-define tool permissions, context resources, and behaviors:

kiro-cli agent list              # List available agents
kiro-cli agent create my-agent   # Create new agent
kiro-cli agent edit my-agent     # Edit agent config
kiro-cli agent validate ./a.json # Validate config file
kiro-cli agent set-default my-agent  # Set default

Benefits: Pre-approve trusted tools, limit tool access, auto-load project docs, share configs across team.

Steering (Project Context)

Provide persistent project knowledge via markdown files in .kiro/steering/:

.kiro/steering/
├── product.md       # Product overview
├── tech.md          # Tech stack
├── structure.md     # Project structure
└── api-standards.md # API conventions

• Workspace steering: .kiro/steering/ — applies to current project only
• Global steering: ~/.kiro/steering/ — applies to all projects
• AGENTS.md support: Place in project root or ~/.kiro/steering/

In custom agents: Add "resources": ["file://.kiro/steering/**/*.md"] to config.

MCP Integration

Connect external tools and data sources via Model Context Protocol:

kiro-cli mcp add --name my-server --command "node server.js" --scope workspace
kiro-cli mcp list [workspace|global]
kiro-cli mcp status --name my-server
kiro-cli mcp remove --name my-server --scope workspace

Other Commands

kiro-cli translate "list all files"    # Natural language → shell command
kiro-cli translate -n 3 "search text"  # Generate multiple options
kiro-cli update                        # Update Kiro CLI
kiro-cli settings list --all           # Show all settings
kiro-cli uninstall                     # Uninstall (macOS)

Plan Agent

Plan Agent is a built-in agent for structured planning before execution. It helps transform ideas into detailed implementation plans.

When to suggest Plan Agent to user:

• Complex multi-step features (e.g., "build a user authentication system")
• Requirements are unclear or need clarification
• Large features that benefit from task breakdown

When NOT to use Plan Agent:

• Simple queries or single-step tasks
• User already has clear, specific instructions
• Quick fixes or small changes

How to use:

# Start Plan mode
> /plan
# Or with immediate prompt
> /plan Build a REST API for user authentication
# Or toggle with keyboard shortcut
Shift + Tab

Plan workflow (4 phases):

1. Requirements gathering — Structured questions with multiple choice options
   • Answer with format: 1=a, 2=b or provide custom answers
2. Research and analysis — Explores codebase, identifies patterns and technologies
3. Implementation plan — Creates detailed task breakdown with clear objectives
4. Handoff to execution — After approval (y), plan transfers to execution agent

Example interaction:

> /plan I want to build a todo app

[plan] > I understand you want to build a todo app.

[1]: What platform should this todo app target?
  a. **Web Application**
  b. **Mobile App**
  c. **CLI Tool**

[2]: What's the primary use case?
  a. **Personal Task Management**
  b. **Team Collaboration**

> 1=c, 2=a

[plan] > *Researching your codebase...*
        *Creating implementation plan...*

**Implementation Plan - Todo CLI**
Task 1: Create database schema...
Task 2: Implement CLI commands...
Task 3: Add advanced features...

Does this plan look good? [y/n]: y

[default] > Implement this plan: [Plan transferred to execution agent]

Plan Agent limitations (read-only):

• ✓ Can read files, search code, research documentation
• ✗ Cannot write files or execute commands (until handoff)

OpenCode

bash pty:true workdir:~/project command:"opencode run 'Your task'"

Pi Coding Agent

# Install: npm install -g @mariozechner/pi-coding-agent
bash pty:true workdir:~/project command:"pi 'Your task'"

# Non-interactive mode (PTY still recommended)
bash pty:true command:"pi -p 'Summarize src/'"

# Different provider/model
bash pty:true command:"pi --provider openai --model gpt-4o-mini -p 'Your task'"

Note: Pi now has Anthropic prompt caching enabled (PR #584, merged Jan 2026)!

Parallel Issue Fixing with git worktrees

For fixing multiple issues in parallel, use git worktrees:

# 1. Create worktrees for each issue
git worktree add -b fix/issue-78 /tmp/issue-78 main
git worktree add -b fix/issue-99 /tmp/issue-99 main

# 2. Launch agent in each (background + PTY!)
bash pty:true workdir:/tmp/issue-78 background:true command:"pnpm install && codex --yolo 'Fix issue #78: <description>. Commit and push.'"
bash pty:true workdir:/tmp/issue-99 background:true command:"pnpm install && codex --yolo 'Fix issue #99: <description>. Commit and push.'"

# 3. Monitor progress
process action:list
process action:log sessionId:XXX

# 4. Create PRs after fixes
cd /tmp/issue-78 && git push -u origin fix/issue-78
gh pr create --repo user/repo --head fix/issue-78 --title "fix: ..." --body "..."

# 5. Cleanup
git worktree remove /tmp/issue-78
git worktree remove /tmp/issue-99

⚠️ Rules

1. Always use pty:true - coding agents need a terminal!
2. Respect tool choice - if user asks for Kiro, use Kiro; if they ask for Codex, use Codex.
   • Orchestrator mode: do NOT hand-code patches yourself.
   • If an agent fails/hangs, respawn it or ask the user for direction, but don't silently take over.
3. Be patient - don't kill sessions because they're "slow"
4. Monitor with process:log - check progress without interfering
5. --full-auto/--yolo for Codex building - auto-approves changes
6. --trust-all-tools for Kiro automation - skips confirmation prompts; use --trust-tools for untrusted input
7. --no-interactive for Kiro one-shots - single response mode
8. Parallel is OK - run many agent processes at once for batch work
9. NEVER start agents in ~/clawd/ - it'll read your soul docs and get weird ideas about the org chart!
10. NEVER checkout branches in ~/Projects/openclaw/ - that's the LIVE OpenClaw instance!
11. Suggest Kiro /plan for complex tasks - when requirements are unclear or task is multi-step, suggest Plan Agent to user and let them decide

Progress Updates (Critical)

When you spawn coding agents in the background, keep the user in the loop.

• Send 1 short message when you start (what's running + where).
• Then only update again when something changes:
  • a milestone completes (build finished, tests passed)
  • the agent asks a question / needs input
  • you hit an error or need user action
  • the agent finishes (include what changed + where)
• If you kill a session, immediately say you killed it and why.

This prevents the user from seeing only "Agent failed before reply" and having no idea what happened.

Auto-Notify on Completion

For long-running background tasks, append a wake trigger to your prompt so OpenClaw gets notified immediately when the agent finishes (instead of waiting for the next heartbeat):

... your task here.

When completely finished, run this command to notify me:
openclaw system event --text "Done: [brief summary of what was built]" --mode now

Example (Codex):

bash pty:true workdir:~/project background:true command:"codex --yolo exec 'Build a REST API for todos.

When completely finished, run: openclaw system event --text \"Done: Built todos REST API with CRUD endpoints\" --mode now'"

This triggers an immediate wake event — gets pinged in seconds, not 10 minutes.

Learnings (Jan 2026)

• PTY is essential: Coding agents are interactive terminal apps. Without pty:true, output breaks or agent hangs.
• Git repo required: Codex won't run outside a git directory. Use mktemp -d && git init for scratch work.
• exec is your friend: codex exec "prompt" runs and exits cleanly - perfect for one-shots.
• submit vs write: Use submit to send input + Enter, write for raw data without newline.
• Sass works: Codex responds well to playful prompts. Asked it to write a haiku about being second fiddle to a space lobster, got: "Second chair, I code / Space lobster sets the tempo / Keys glow, I follow" 🦞

Learnings (Feb 2026)

• Kiro CLI: AWS coding assistant with unique features — session persistence, custom agents, steering, MCP.
• No git required: Unlike Codex, Kiro runs in any directory.
• Flexible auth: GitHub/Google/AWS Builder ID/IAM Identity Center.
• Remote login: Builder ID/IAM uses device code (easy). Social login needs SSH port forwarding.
• Tool trust: --trust-all-tools for full automation, --trust-tools for fine-grained control.
• Session resume: --resume continues last conversation, --resume-picker for history browser.
• Steering: .kiro/steering/*.md provides persistent project context. Also supports AGENTS.md standard.
• Kiro + OpenClaw: --no-interactive for simple queries; interactive mode for multi-turn tasks (can run foreground or background).
• Plan Agent option: For complex multi-step tasks in Kiro, suggest /plan to user — it clarifies requirements, researches codebase, creates task breakdown, then hands off to execution.