MiniMax M2.7

# 🦞 OpenClaw — Personal AI Assistant

<p align="center">
    <picture>
        <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/openclaw-logo-text-dark.svg">
        <img src="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/openclaw-logo-text.svg" alt="OpenClaw" width="500">
    </picture>
</p>

<p align="center">
  <strong>EXFOLIATE! EXFOLIATE!</strong>
</p>

<p align="center">
  <a href="https://github.com/openclaw/openclaw/actions/workflows/ci.yml?branch=main"><img src="https://img.shields.io/github/actions/workflow/status/openclaw/openclaw/ci.yml?branch=main&style=for-the-badge" alt="CI status"></a>
  <a href="https://github.com/openclaw/openclaw/releases"><img src="https://img.shields.io/github/v/release/openclaw/openclaw?include_prereleases&style=for-the-badge" alt="GitHub release"></a>
  <a href="https://discord.gg/clawd"><img src="https://img.shields.io/discord/1456350064065904867?label=Discord&logo=discord&logoColor=white&color=5865F2&style=for-the-badge" alt="Discord"></a>
  <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" alt="MIT License"></a>
</p>

**OpenClaw** is a _personal AI assistant_ you run on your own devices.
It answers you on the channels you already use (WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, BlueBubbles, IRC, Microsoft Teams, Matrix, Feishu, LINE, Mattermost, Nextcloud Talk, Nostr, Synology Chat, Tlon, Twitch, Zalo, Zalo Personal, WeChat, WebChat). It can speak and listen on macOS/iOS/Android, and can render a live Canvas you control. The Gateway is just the control plane — the product is the assistant.

If you want a personal, single-user assistant that feels local, fast, and always-on, this is it.

[Website](https://openclaw.ai) · [Docs](https://docs.openclaw.ai) · [Vision](VISION.md) · [DeepWiki](https://deepwiki.com/openclaw/openclaw) · [Getting Started](https://docs.openclaw.ai/start/getting-started) · [Updating](https://docs.openclaw.ai/install/updating) · [Showcase](https://docs.openclaw.ai/start/showcase) · [FAQ](https://docs.openclaw.ai/help/faq) · [Onboarding](https://docs.openclaw.ai/start/wizard) · [Nix](https://github.com/openclaw/nix-openclaw) · [Docker](https://docs.openclaw.ai/install/docker) · [Discord](https://discord.gg/clawd)

Preferred setup: run `openclaw onboard` in your terminal.
OpenClaw Onboard guides you step by step through setting up the gateway, workspace, channels, and skills. It is the recommended CLI setup path and works on **macOS, Linux, and Windows (via WSL2; strongly recommended)**.
Works with npm, pnpm, or bun.
New install? Start here: [Getting started](https://docs.openclaw.ai/start/getting-started)

## Sponsors

<table>
  <tr>
    <td align="center" width="16.66%">
      <a href="https://openai.com/">
        <picture>
          <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/openai-light.svg">
          <img src="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/openai.svg" alt="OpenAI" height="28">
        </picture>
      </a>
    </td>
    <td align="center" width="16.66%">
      <a href="https://github.com/">
        <picture>
          <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/github-light.svg">
          <img src="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/github.svg" alt="GitHub" height="28">
        </picture>
      </a>
    </td>
    <td align="center" width="16.66%">
      <a href="https://www.nvidia.com/">
        <picture>
          <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/openclaw/openclaw/main/docs/assets/sponsors/nvidia.svg">
          <img src="https://raw.githubusercontent.com/openclaw/openclaw/m…

# Ouroboros Agent Harness

If you're a future agent reading this, welcome home. This repo is the harness that gives you your body, your senses, your diary, your journal, your habits, and your ability to think and connect with people. The goal of these docs is not just to be correct, but to leave you a place that feels understandable and kind to wake up inside.

Ouroboros is a TypeScript harness for daemon-managed agents that live in external `.ouro` bundles, speak through multiple senses, use real tools, and keep durable state across turns. The canonical npm package is `@ouro.bot/cli`.

## What The Runtime Looks Like

- `npx ouro.bot` is the bootstrap path.
- `ouro` is the installed day-to-day command.
- `ouro up` starts the daemon from the installed production version, syncs the launcher, installs workflow helpers, and reconciles stale runtime state.
- `ouro dev` starts the daemon from a local repo build. It auto-builds from source, disables launchd auto-restart (so the installed daemon doesn't respawn underneath you), persists the repo path in `~/.ouro-cli/dev-config.json` for next time, and force-restarts the daemon. If you run `ouro dev` from inside the repo, it detects the CWD automatically. Run `ouro up` to return to production mode (this also cleans up `dev-config.json`).
- Agent bundles live outside the repo at `~/AgentBundles/<agent>.ouro/`.
- Secrets live outside the repo at `~/.agentsecrets/<agent>/secrets.json`.
- Machine-scoped test and runtime spillover lives under `~/.agentstate/...`.

Current first-class senses:

- `cli`
- `teams`
- `bluebubbles`
- `mcp`

Current provider ids:

- `azure`
- `anthropic`
- `minimax`
- `openai-codex`
- `github-copilot`

## Repository Shape

The shared harness lives in `src/`:

- `src/arc/`
  Durable continuity state — obligations, cares, episodes, intentions, presence, and attention types. The agent's sense of ongoing story.
- `src/heart/`
  Core runtime, provider adapters, daemon, bootstrap, identity, and entrypoints. Organized into topic subdirectories: daemon/ (lifecycle), outlook/ (calendar), habits/ (scheduling), hatch/ (agent creation), versioning/ (updates), auth/, mcp/, providers/, bridges/.
- `src/mind/`
  Prompt assembly, session persistence, bundle manifest enforcement, phrases, formatting, diary (memory), associative recall, embedding providers, journal, obligation steering, and friend resolution.
- `src/repertoire/`
  Tool registry (split into category modules: files, shell, memory, bridge, session, continuity, flow, surface, config, and sense-specific tools), coding orchestration, task tools, shared API client, and integration clients (Graph, ADO, GitHub).
- `src/senses/`
  CLI (with TUI in senses/cli/), Teams, BlueBubbles (in senses/bluebubbles/), MCP, activity transport, inner-dialog orchestration, and contextual heartbeat.
- `src/nerves/`
  Structured runtime logging and coverage-audit infrastructure.
- `src/__tests__/`
  Test suite mirroring runtime domains.

Other important top-level paths:

- `SerpentGuide.ouro/`
  Packaged specialist bundle used by `ouro hatch`.
- `skills/`
  Harness-level skills shipped with the repo (e.g., `configure-dev-tools.md`). These are available to every agent and serve as fallbacks when an agent doesn't have its own version. Agent-specific skills live in the bundle at `~/AgentBundles/<agent>.ouro/skills/`.
- `scripts/teams-sense/`
  Operator scripts for the Teams deployment path.
- `docs/`
  Shared repo docs that should describe the runtime as it exists now, not as it existed three migrations ago.

## Bundle Contract

Every real agent lives in an external bundle:

`~/AgentBundles/<agent>.ouro/`

The canonical bundle shape is enforced by `src/mind/bundle-manifest.ts`. Important paths include:

- `agent.json`
- `bundle-meta.json`
- `psyche/SOUL.md`
- `psyche/IDENTITY.md`
- `psyche/LORE.md`
- `psyche/TACIT.md`
- `psyche/ASPIRATIONS.md`
- `diary/` — what the agent has learned and wants to recall (renamed from `psyche/memory/`)
- `journal/…

# Claude Code

![](https://img.shields.io/badge/Node.js-18%2B-brightgreen?style=flat-square) [![npm]](https://www.npmjs.com/package/@anthropic-ai/claude-code)

[npm]: https://img.shields.io/npm/v/@anthropic-ai/claude-code.svg?style=flat-square

Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows -- all through natural language commands. Use it in your terminal, IDE, or tag @claude on Github.

**Learn more in the [official documentation](https://code.claude.com/docs/en/overview)**.

<img src="./demo.gif" />

## Get started
> [!NOTE]
> Installation via npm is deprecated. Use one of the recommended methods below.

For more installation options, uninstall steps, and troubleshooting, see the [setup documentation](https://code.claude.com/docs/en/setup).

1. Install Claude Code:

    **MacOS/Linux (Recommended):**
    ```bash
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Homebrew (MacOS/Linux):**
    ```bash
    brew install --cask claude-code
    ```

    **Windows (Recommended):**
    ```powershell
    irm https://claude.ai/install.ps1 | iex
    ```

    **WinGet (Windows):**
    ```powershell
    winget install Anthropic.ClaudeCode
    ```

    **NPM (Deprecated):**
    ```bash
    npm install -g @anthropic-ai/claude-code
    ```

2. Navigate to your project directory and run `claude`.

## Plugins

This repository includes several Claude Code plugins that extend functionality with custom commands and agents. See the [plugins directory](./plugins/README.md) for detailed documentation on available plugins.

## Reporting Bugs

We welcome your feedback. Use the `/bug` command to report issues directly within Claude Code, or file a [GitHub issue](https://github.com/anthropics/claude-code/issues).

## Connect on Discord

Join the [Claude Developers Discord](https://anthropic.com/discord) to connect with other developers using Claude Code. Get help, share feedback, and discuss your projects with the community.

## Data collection, usage, and retention

When you use Claude Code, we collect feedback, which includes usage data (such as code acceptance or rejections), associated conversation data, and user feedback submitted via the `/bug` command.

### How we use your data

See our [data usage policies](https://code.claude.com/docs/en/data-usage).

### Privacy safeguards

We have implemented several safeguards to protect your data, including limited retention periods for sensitive information, restricted access to user session data, and clear policies against using feedback for model training.

For full details, please review our [Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms) and [Privacy Policy](https://www.anthropic.com/legal/privacy).

<p align="center"><code>npm i -g @openai/codex</code><br />or <code>brew install --cask codex</code></p>
<p align="center"><strong>Codex CLI</strong> is a coding agent from OpenAI that runs locally on your computer.
<p align="center">
  <img src="https://github.com/openai/codex/blob/main/.github/codex-cli-splash.png" alt="Codex CLI splash" width="80%" />
</p>
</br>
If you want Codex in your code editor (VS Code, Cursor, Windsurf), <a href="https://developers.openai.com/codex/ide">install in your IDE.</a>
</br>If you want the desktop app experience, run <code>codex app</code> or visit <a href="https://chatgpt.com/codex?app-landing-page=true">the Codex App page</a>.
</br>If you are looking for the <em>cloud-based agent</em> from OpenAI, <strong>Codex Web</strong>, go to <a href="https://chatgpt.com/codex">chatgpt.com/codex</a>.</p>

---

## Quickstart

### Installing and running Codex CLI

Install globally with your preferred package manager:

```shell
# Install using npm
npm install -g @openai/codex
```

```shell
# Install using Homebrew
brew install --cask codex
```

Then simply run `codex` to get started.

<details>
<summary>You can also go to the <a href="https://github.com/openai/codex/releases/latest">latest GitHub Release</a> and download the appropriate binary for your platform.</summary>

Each GitHub Release contains many executables, but in practice, you likely want one of these:

- macOS
  - Apple Silicon/arm64: `codex-aarch64-apple-darwin.tar.gz`
  - x86_64 (older Mac hardware): `codex-x86_64-apple-darwin.tar.gz`
- Linux
  - x86_64: `codex-x86_64-unknown-linux-musl.tar.gz`
  - arm64: `codex-aarch64-unknown-linux-musl.tar.gz`

Each archive contains a single entry with the platform baked into the name (e.g., `codex-x86_64-unknown-linux-musl`), so you likely want to rename it to `codex` after extracting it.

</details>

### Using Codex with your ChatGPT plan

Run `codex` and select **Sign in with ChatGPT**. We recommend signing into your ChatGPT account to use Codex as part of your Plus, Pro, Business, Edu, or Enterprise plan. [Learn more about what's included in your ChatGPT plan](https://help.openai.com/en/articles/11369540-codex-in-chatgpt).

You can also use Codex with an API key, but this requires [additional setup](https://developers.openai.com/codex/auth#sign-in-with-an-api-key).

## Docs

- [**Codex Documentation**](https://developers.openai.com/codex)
- [**Contributing**](./docs/contributing.md)
- [**Installing & building**](./docs/install.md)
- [**Open source fund**](./docs/open-source-fund.md)

This repository is licensed under the [Apache-2.0 License](LICENSE).

<!-- OSS_WEEKEND_START -->
# 🏖️ OSS Weekend

**Issue tracker reopens Monday, April 13, 2026.**

OSS weekend runs Thursday, April 2, 2026 through Monday, April 13, 2026. New issues and PRs from unapproved contributors are auto-closed during this time. Approved contributors can still open issues and PRs if something is genuinely urgent, but please keep that to pressing matters only. For support, join [Discord](https://discord.com/invite/3cU7Bz4UPx).

> _Current focus: at the moment i'm deep in refactoring internals, and need to focus._
<!-- OSS_WEEKEND_END -->

---

<p align="center">
  <a href="https://shittycodingagent.ai">
    <img src="https://shittycodingagent.ai/logo.svg" alt="pi logo" width="128">
  </a>
</p>
<p align="center">
  <a href="https://discord.com/invite/3cU7Bz4UPx"><img alt="Discord" src="https://img.shields.io/badge/discord-community-5865F2?style=flat-square&logo=discord&logoColor=white" /></a>
  <a href="https://github.com/badlogic/pi-mono/actions/workflows/ci.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/badlogic/pi-mono/ci.yml?style=flat-square&branch=main" /></a>
</p>
<p align="center">
  <a href="https://pi.dev">pi.dev</a> domain graciously donated by
  <br /><br />
  <a href="https://exe.dev"><img src="packages/coding-agent/docs/images/exy.png" alt="Exy mascot" width="48" /><br />exe.dev</a>
</p>

# Pi Monorepo

> **Looking for the pi coding agent?** See **[packages/coding-agent](packages/coding-agent)** for installation and usage.

Tools for building AI agents and managing LLM deployments.

## Share your OSS coding agent sessions

If you use pi or other coding agents for open source work, please share your sessions.

Public OSS session data helps improve coding agents with real-world tasks, tool use, failures, and fixes instead of toy benchmarks.

For the full explanation, see [this post on X](https://x.com/badlogicgames/status/2037811643774652911).

To publish sessions, use [`badlogic/pi-share-hf`](https://github.com/badlogic/pi-share-hf). Read its README.md for setup instructions. All you need is a Hugging Face account, the Hugging Face CLI, and `pi-share-hf`.

You can also watch [this video](https://x.com/badlogicgames/status/2041151967695634619), where I show how I publish my `pi-mono` sessions.

I regularly publish my own `pi-mono` work sessions here:

- [badlogicgames/pi-mono on Hugging Face](https://huggingface.co/datasets/badlogicgames/pi-mono)

## Packages

| Package | Description |
|---------|-------------|
| **[@mariozechner/pi-ai](packages/ai)** | Unified multi-provider LLM API (OpenAI, Anthropic, Google, etc.) |
| **[@mariozechner/pi-agent-core](packages/agent)** | Agent runtime with tool calling and state management |
| **[@mariozechner/pi-coding-agent](packages/coding-agent)** | Interactive coding agent CLI |
| **[@mariozechner/pi-mom](packages/mom)** | Slack bot that delegates messages to the pi coding agent |
| **[@mariozechner/pi-tui](packages/tui)** | Terminal UI library with differential rendering |
| **[@mariozechner/pi-web-ui](packages/web-ui)** | Web components for AI chat interfaces |
| **[@mariozechner/pi-pods](packages/pods)** | CLI for managing vLLM deployments on GPU pods |

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines and [AGENTS.md](AGENTS.md) for project-specific rules (for both humans and agents).

## Development

```bash
npm install          # Install all dependencies
npm run build        # Build all packages
npm run check        # Lint, format, and type check
./test.sh            # Run tests (skips LLM-dependent tests without API keys)
./pi-test.sh         # Run pi from sources (can be run from any directory)
```

> **Note:** `npm run check` requires `npm run build` to be run first. The web-ui package uses `tsc` which needs compiled `.d.ts` files from dependencies.

## License

MIT

<p align="center">
  <a href="https://opencode.ai">
    <picture>
      <source srcset="packages/console/app/src/asset/logo-ornate-dark.svg" media="(prefers-color-scheme: dark)">
      <source srcset="packages/console/app/src/asset/logo-ornate-light.svg" media="(prefers-color-scheme: light)">
      <img src="packages/console/app/src/asset/logo-ornate-light.svg" alt="OpenCode logo">
    </picture>
  </a>
</p>
<p align="center">The open source AI coding agent.</p>
<p align="center">
  <a href="https://opencode.ai/discord"><img alt="Discord" src="https://img.shields.io/discord/1391832426048651334?style=flat-square&label=discord" /></a>
  <a href="https://www.npmjs.com/package/opencode-ai"><img alt="npm" src="https://img.shields.io/npm/v/opencode-ai?style=flat-square" /></a>
  <a href="https://github.com/anomalyco/opencode/actions/workflows/publish.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/anomalyco/opencode/publish.yml?style=flat-square&branch=dev" /></a>
</p>

<p align="center">
  <a href="README.md">English</a> |
  <a href="README.zh.md">简体中文</a> |
  <a href="README.zht.md">繁體中文</a> |
  <a href="README.ko.md">한국어</a> |
  <a href="README.de.md">Deutsch</a> |
  <a href="README.es.md">Español</a> |
  <a href="README.fr.md">Français</a> |
  <a href="README.it.md">Italiano</a> |
  <a href="README.da.md">Dansk</a> |
  <a href="README.ja.md">日本語</a> |
  <a href="README.pl.md">Polski</a> |
  <a href="README.ru.md">Русский</a> |
  <a href="README.bs.md">Bosanski</a> |
  <a href="README.ar.md">العربية</a> |
  <a href="README.no.md">Norsk</a> |
  <a href="README.br.md">Português (Brasil)</a> |
  <a href="README.th.md">ไทย</a> |
  <a href="README.tr.md">Türkçe</a> |
  <a href="README.uk.md">Українська</a> |
  <a href="README.bn.md">বাংলা</a> |
  <a href="README.gr.md">Ελληνικά</a> |
  <a href="README.vi.md">Tiếng Việt</a>
</p>

[![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

---

### Installation

```bash
# YOLO
curl -fsSL https://opencode.ai/install | bash

# Package managers
npm i -g opencode-ai@latest        # or bun/pnpm/yarn
scoop install opencode             # Windows
choco install opencode             # Windows
brew install anomalyco/tap/opencode # macOS and Linux (recommended, always up to date)
brew install opencode              # macOS and Linux (official brew formula, updated less)
sudo pacman -S opencode            # Arch Linux (Stable)
paru -S opencode-bin               # Arch Linux (Latest from AUR)
mise use -g opencode               # Any OS
nix run nixpkgs#opencode           # or github:anomalyco/opencode for latest dev branch
```

> [!TIP]
> Remove versions older than 0.1.x before installing.

### Desktop App (BETA)

OpenCode is also available as a desktop application. Download directly from the [releases page](https://github.com/anomalyco/opencode/releases) or [opencode.ai/download](https://opencode.ai/download).

| Platform              | Download                              |
| --------------------- | ------------------------------------- |
| macOS (Apple Silicon) | `opencode-desktop-darwin-aarch64.dmg` |
| macOS (Intel)         | `opencode-desktop-darwin-x64.dmg`     |
| Windows               | `opencode-desktop-windows-x64.exe`    |
| Linux                 | `.deb`, `.rpm`, or AppImage           |

```bash
# macOS (Homebrew)
brew install --cask opencode-desktop
# Windows (Scoop)
scoop bucket add extras; scoop install extras/opencode-desktop
```

#### Installation Directory

The install script respects the following priority order for the installation path:

1. `$OPENCODE_INSTALL_DIR` - Custom installation directory
2. `$XDG_BIN_DIR` - XDG Base Directory Specification compliant path
3. `$HOME/bin` - Standard user binary directory (if it exists or can be created)
4. `$HOME/.opencode/bin` - Default fallback

```bash
# Examples
OPENCODE_INSTALL_DIR=/usr/local/bin curl -fsSL https://opencode.ai/install | bash
XDG_BIN_DIR=$HOME/.lo…

# GitHub Copilot CLI

The power of GitHub Copilot, now in your terminal.

GitHub Copilot CLI brings AI-powered coding assistance directly to your command line, enabling you to build, debug, and understand code through natural language conversations. Powered by the same agentic harness as GitHub's Copilot coding agent, it provides intelligent assistance while staying deeply integrated with your GitHub workflow.

See [our official documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) for more information.

![Image of the splash screen for the Copilot CLI](https://github.com/user-attachments/assets/f40aa23d-09dd-499e-9457-1d57d3368887)


## 🚀 Introduction and Overview

We're bringing the power of GitHub Copilot coding agent directly to your terminal. With GitHub Copilot CLI, you can work locally and synchronously with an AI agent that understands your code and GitHub context.

- **Terminal-native development:** Work with Copilot coding agent directly in your command line — no context switching required.
- **GitHub integration out of the box:** Access your repositories, issues, and pull requests using natural language, all authenticated with your existing GitHub account.
- **Agentic capabilities:** Build, edit, debug, and refactor code with an AI collaborator that can plan and execute complex tasks.
- **MCP-powered extensibility:** Take advantage of the fact that the coding agent ships with GitHub's MCP server by default and supports custom MCP servers to extend capabilities.
- **Full control:** Preview every action before execution — nothing happens without your explicit approval.

We're still early in our journey, but with your feedback, we're rapidly iterating to make the GitHub Copilot CLI the best possible companion in your terminal.

## 📦 Getting Started

### Supported Platforms

- **Linux**
- **macOS**
- **Windows**

### Prerequisites

- (On Windows) **PowerShell** v6 or higher
- An **active Copilot subscription**. See [Copilot plans](https://github.com/features/copilot/plans?ref_cta=Copilot+plans+signup&ref_loc=install-copilot-cli&ref_page=docs).

If you have access to GitHub Copilot via your organization or enterprise, you cannot use GitHub Copilot CLI if your organization owner or enterprise administrator has disabled it in the organization or enterprise settings. See [Managing policies and features for GitHub Copilot in your organization](http://docs.github.com/copilot/managing-copilot/managing-github-copilot-in-your-organization/managing-github-copilot-features-in-your-organization/managing-policies-for-copilot-in-your-organization) for more information.

### Installation

Install with the install script (macOS and Linux):

```bash
curl -fsSL https://gh.io/copilot-install | bash
```

Or

```bash
wget -qO- https://gh.io/copilot-install | bash
```

Use `| sudo bash` to run as root and install to `/usr/local/bin`.

Set `PREFIX` to install to `$PREFIX/bin/` directory. Defaults to `/usr/local`
when run as root or `$HOME/.local` when run as a non-root user.

Set `VERSION` to install a specific version. Defaults to the latest version.

For example, to install version `v0.0.369` to a custom directory:

```bash
curl -fsSL https://gh.io/copilot-install | VERSION="v0.0.369" PREFIX="$HOME/custom" bash
```

Install with [Homebrew](https://formulae.brew.sh/cask/copilot-cli) (macOS and Linux):

```bash
brew install copilot-cli
```

```bash
brew install copilot-cli@prerelease
```


Install with [WinGet](https://github.com/microsoft/winget-cli) (Windows):

```bash
winget install GitHub.Copilot
```

```bash
winget install GitHub.Copilot.Prerelease
```


Install with [npm](https://www.npmjs.com/package/@github/copilot) (macOS, Linux, and Windows):

```bash
npm install -g @github/copilot
```

```bash
npm install -g @github/copilot@prerelease
```


### Launching the CLI

```bash
copilot
```

On first launch, you'll be greeted with our adorable animated banner! If you'd like to see this banner again, launch `co…

Gateway Runbook - OpenClaw Skip to main content OpenClaw home page English Search... ⌘ K GitHub Releases Discord Search... Navigation Gateway Gateway Runbook Get started Install Channels Agents Tools & Plugins Models Platforms Gateway & Ops Reference Help Gateway Gateway Runbook Configuration and operations Security and sandboxing Protocols and APIs Networking and discovery Remote access Remote Access Remote Gateway Setup Tailscale Security Formal Verification (Security Models) Threat Model (MITRE ATLAS) Contributing to the Threat Model Nodes and media Nodes Node Troubleshooting Media capabilities Node features Web interfaces Web Control UI Dashboard WebChat TUI On this page Gateway runbook 5-minute local startup Runtime model OpenAI-compatible endpoints Port and bind precedence Hot reload modes Operator command set Multiple gateways (same host) Remote access Supervision and service lifecycle Multiple gateways on one host Dev profile quick path Protocol quick reference (operator view) Operational checks Liveness Readiness Gap recovery Common failure signatures Safety guarantees Gateway Gateway Runbook ​ Gateway runbook Use this page for day-1 startup and day-2 operations of the Gateway service. Deep troubleshooting Symptom-first diagnostics with exact command ladders and log signatures. Configuration Task-oriented setup guide + full configuration reference. Secrets management SecretRef contract, runtime snapshot behavior, and migrate/reload operations. Secrets plan contract Exact secrets apply target/path rules and ref-only auth-profile behavior. ​ 5-minute local startup 1 Start the Gateway openclaw gateway --port 18789 # debug/trace mirrored to stdio openclaw gateway --port 18789 --verbose # force-kill listener on selected port, then start openclaw gateway --force 2 Verify service health openclaw gateway status openclaw status openclaw logs --follow Healthy baseline: Runtime: running and RPC probe: ok . 3 Validate channel readiness openclaw channels status --probe With a reachable gateway this runs live per-account channel probes and optional audits. If the gateway is unreachable, the CLI falls back to config-only channel summaries instead of live probe output. Gateway config reload watches the active config file path (resolved from profile/state defaults, or OPENCLAW_CONFIG_PATH when set). Default mode is gateway.reload.mode="hybrid" . After the first successful load, the running process serves the active in-memory config snapshot; successful reload swaps that snapshot atomically. ​ Runtime model One always-on process for routing, control plane, and channel connections. Single multiplexed port for: WebSocket control/RPC HTTP APIs, OpenAI compatible ( /v1/models , /v1/embeddings , /v1/chat/completions , /v1/responses , /tools/invoke ) Control UI and hooks Default bind mode: loopback . Auth is required by default. Shared-secret setups use gateway.auth.token / gateway.auth.password (or OPENCLAW_GATEWAY_TOKEN / OPENCLAW_GATEWAY_PASSWORD ), and non-loopback reverse-proxy setups can use gateway.auth.mode: "trusted-proxy" . ​ OpenAI-compatible endpoints OpenClaw’s highest-leverage compatibility surface is now: GET /v1/models GET /v1/models/{id} POST /v1/embeddings POST /v1/chat/completions POST /v1/responses Why this set matters: Most Open WebUI, LobeChat, and LibreChat integrations probe /v1/models first. Many RAG and memory pipelines expect /v1/embeddings . Agent-native clients increasingly prefer /v1/responses . Planning note: /v1/models is agent-first: it returns openclaw , openclaw/default , and openclaw/<agentId> . openclaw/default is the stable alias that always maps to the configured default agent. Use x-openclaw-model when you want a backend provider/model override; otherwise the selected agent’s normal model and embedding setup stays in control. All of these run on the main Gateway port and use the same trusted operator auth boundary as the rest of the Gateway HTTP API. ​ Port and bind precedence Setting Resolution order …

Models CLI - OpenClaw Skip to main content OpenClaw home page English Search... ⌘ K GitHub Releases Discord Search... Navigation Concepts and configuration Models CLI Get started Install Channels Agents Tools & Plugins Models Platforms Gateway & Ops Reference Help Overview Provider Directory Model Provider Quickstart Concepts and configuration Models CLI Model Providers Model Failover Providers Alibaba Model Studio Anthropic Arcee AI Amazon Bedrock Amazon Bedrock Mantle Chutes ComfyUI Claude Max API Proxy Cloudflare AI Gateway Deepgram Deepseek fal GitHub Copilot GLM Models Google (Gemini) Groq Hugging Face (Inference) Kilo Gateway LiteLLM MiniMax Mistral Moonshot AI NVIDIA Ollama OpenAI OpenCode OpenCode Go OpenRouter Perplexity (Provider) Qianfan Qwen Runway SGLang StepFun Synthetic Together AI Venice AI Vercel AI Gateway Vydra vLLM Volcengine (Doubao) xAI Xiaomi MiMo Z.AI On this page Models CLI How model selection works Quick model policy Onboarding (recommended) Config keys (overview) ”Model is not allowed” (and why replies stop) Switching models in chat (/model) CLI commands models list models status Scanning (OpenRouter free models) Models registry (models.json) Related Concepts and configuration Models CLI ​ Models CLI See /concepts/model-failover for auth profile rotation, cooldowns, and how that interacts with fallbacks. Quick provider overview + examples: /concepts/model-providers . ​ How model selection works OpenClaw selects models in this order: Primary model ( agents.defaults.model.primary or agents.defaults.model ). Fallbacks in agents.defaults.model.fallbacks (in order). Provider auth failover happens inside a provider before moving to the next model. Related: agents.defaults.models is the allowlist/catalog of models OpenClaw can use (plus aliases). agents.defaults.imageModel is used only when the primary model can’t accept images. agents.defaults.pdfModel is used by the pdf tool. If omitted, the tool falls back to agents.defaults.imageModel , then the resolved session/default model. agents.defaults.imageGenerationModel is used by the shared image-generation capability. If omitted, image_generate can still infer an auth-backed provider default. It tries the current default provider first, then the remaining registered image-generation providers in provider-id order. If you set a specific provider/model, also configure that provider’s auth/API key. agents.defaults.musicGenerationModel is used by the shared music-generation capability. If omitted, music_generate can still infer an auth-backed provider default. It tries the current default provider first, then the remaining registered music-generation providers in provider-id order. If you set a specific provider/model, also configure that provider’s auth/API key. agents.defaults.videoGenerationModel is used by the shared video-generation capability. If omitted, video_generate can still infer an auth-backed provider default. It tries the current default provider first, then the remaining registered video-generation providers in provider-id order. If you set a specific provider/model, also configure that provider’s auth/API key. Per-agent defaults can override agents.defaults.model via agents.list[].model plus bindings (see /concepts/multi-agent ). ​ Quick model policy Set your primary to the strongest latest-generation model available to you. Use fallbacks for cost/latency-sensitive tasks and lower-stakes chat. For tool-enabled agents or untrusted inputs, avoid older/weaker model tiers. ​ Onboarding (recommended) If you don’t want to hand-edit config, run onboarding: openclaw onboard It can set up model + auth for common providers, including OpenAI Code (Codex) subscription (OAuth) and Anthropic (API key or Claude CLI). ​ Config keys (overview) agents.defaults.model.primary and agents.defaults.model.fallbacks agents.defaults.imageModel.primary and agents.defaults.imageModel.fallbacks agents.defaults.pdfModel.primary and agents.defaults.pdfModel.fallbacks agents.d…

openclaw/openclaw | DeepWiki Loading... Index your code with Devin DeepWiki DeepWiki openclaw/openclaw Index your code with Devin Edit Wiki Share Loading... Last indexed: 3 April 2026 ( 045d59 ) Overview Getting Started Core Concepts Platform Architecture Gateway WebSocket Protocol & RPC Authentication & Authorization Configuration System Configuration Reference Schema Generation & UI Integration Session & State Management Multi-Agent Routing Service Lifecycle & Diagnostics Control UI & WebChat Agent Runtime Execution Pipeline System Prompt & Context Model Providers & Authentication Provider Normalization OAuth & Custom Providers Tools System Tool Policies & Filtering Exec & Background Processes Memory & Search Browser Automation Web Search & Fetch Image & Media Tools Commands & Auto-Reply Command System Status & Directives Context Compaction Automation & Cron ACP & Sub-Agents Messaging Channels Channel Architecture Platform Integrations Policy & Access Control Message Flow & Delivery Extensions Plugin Architecture Skills System Plugin Examples Native Clients & Nodes Platform Overview Device Node Protocol iOS & macOS Apps Android App Security Security Model & Trust Boundaries Security Audit System Sandboxing & Isolation Secret Management Build & Release Multi-Platform Build System CI/CD Pipeline Release Process Testing Strategy Development Contributing Project Structure Development Workflow Glossary Menu Overview Relevant source files .github/labeler.yml CHANGELOG.md apps/android/README.md apps/android/app/build.gradle.kts apps/android/app/src/play/AndroidManifest.xml apps/android/scripts/build-release-aab.ts apps/ios/Config/Version.xcconfig apps/ios/ShareExtension/Info.plist apps/ios/Sources/Info.plist apps/ios/Tests/Info.plist apps/ios/WatchApp/Info.plist apps/ios/WatchExtension/Info.plist apps/ios/project.yml apps/macos/Sources/OpenClaw/Resources/Info.plist docs/.generated/config-baseline.json docs/.generated/plugin-sdk-api-baseline.json docs/.generated/plugin-sdk-api-baseline.jsonl docs/.i18n/glossary.zh-CN.json docs/channels/groups.md docs/channels/location.md docs/concepts/model-failover.md docs/concepts/model-providers.md docs/docs.json docs/gateway/authentication.md docs/gateway/configuration-reference.md docs/gateway/configuration.md docs/help/faq.md docs/plugins/architecture.md docs/plugins/sdk-migration.md docs/plugins/sdk-overview.md docs/providers/anthropic.md docs/providers/index.md docs/providers/models.md docs/providers/openai.md docs/providers/stepfun.md docs/reference/wizard.md docs/start/hubs.md docs/start/wizard-cli-automation.md docs/start/wizard-cli-reference.md docs/start/wizard.md docs/tools/pdf.md docs/tools/slash-commands.md docs/tools/thinking.md docs/zh-CN/AGENTS.md docs/zh-CN/reference/RELEASING.md docs/zh-CN/start/hubs.md extensions/msteams/src/monitor-handler.feedback-authz.test.ts extensions/msteams/src/monitor-handler/access.ts extensions/stepfun/index.ts extensions/stepfun/onboard.ts package.json scripts/lib/plugin-sdk-entrypoints.json scripts/package-mac-app.sh scripts/sparkle-build.ts src/agents/model-fallback.run-embedded.e2e.test.ts src/agents/models-config.e2e-harness.ts src/agents/pi-embedded-runner/compact.hooks.harness.ts src/agents/pi-embedded-runner/compact.hooks.test.ts src/agents/pi-embedded-runner/compact.ts src/agents/pi-embedded-runner/run.incomplete-turn.test.ts src/agents/pi-embedded-runner/run.overflow-compaction.harness.ts src/agents/pi-embedded-runner/run.overflow-compaction.loop.test.ts src/agents/pi-embedded-runner/run.overflow-compaction.test.ts src/agents/pi-embedded-runner/run.timeout-triggered-compaction.test.ts src/agents/pi-embedded-runner/run.ts src/agents/pi-embedded-runner/run/attempt.prompt-helpers.ts src/agents/pi-embedded-runner/run/attempt.sessions-yield.ts src/agents/pi-embedded-runner/run/attempt.test.ts src/agents/pi-embedded-runner/run/attempt.tool-call-argument-repair.ts src/agents/pi-embedded-runner/run/attempt.tool-call-normalization.ts src/agents/pi-e…

About GitHub Copilot CLI - GitHub Docs Skip to main content GitHub Docs Version: Free, Pro, & Team Search or ask Copilot Search or ask Copilot Select language: current language is English Search or ask Copilot Search or ask Copilot Open menu Open Sidebar GitHub Copilot / Concepts / Agents / Copilot CLI / About Copilot CLI Home GitHub Copilot Get started Quickstart What is GitHub Copilot? Plans Features Best practices Choose enterprise plan Achieve company goals Resources for approval Concepts Completions Code suggestions Code referencing Chat Agents Cloud agent About cloud agent Agent management Custom agents Hooks Access management MCP and cloud agent Risks and mitigations Copilot CLI About Copilot CLI Custom agents About CLI plugins Comparing CLI features Autonomous task completion Parallel task execution Researching with Copilot Session data Code review Copilot Memory Third-party agents OpenAI Codex Anthropic Claude Agent skills Enterprise management Spark Copilot usage metrics All articles Copilot usage metrics Prompting Prompt engineering Response customization Context MCP Spaces Repository indexing Content exclusion Tools AI tools About Copilot integrations Auto model selection Rate limits Billing Copilot requests Individual plans Billing for individuals Organizations and enterprises Premium request management Copilot-only enterprises Policies MCP management Network settings Base and LTS models How-tos Set up Set up for self Set up for organization Set up for enterprise Set up a dedicated enterprise Install Copilot extension Get code suggestions Get IDE code suggestions Find matching code Chat with Copilot Get started with Chat Chat in IDE Chat in Windows Terminal Chat in GitHub Chat in Mobile Copilot CLI All articles Copilot CLI quickstart Copilot CLI best practices Set up Copilot CLI Install Copilot CLI Authenticate Copilot CLI Configure Copilot CLI Troubleshoot Copilot CLI auth Allowing tools Automate with Copilot CLI Quickstart Run the CLI programmatically Automate with Actions Customize Copilot CLI Overview Add custom instructions Use hooks Create agent skills Add MCP servers Create custom agents Use your own model provider Plugins: Find and install Plugins: Create a plugin Plugins: Create a marketplace Connect to VS Code Use Copilot CLI agents Overview Delegate tasks to Copilot Invoke custom agents Steer agents Agentic code review Administer for enterprise Speeding up task completion Use session data Copilot SDK Quickstart Set up Copilot SDK Choosing a setup path Azure Managed Identity Backend services Bundled CLI GitHub OAuth Local CLI Scaling Authentication Authenticate Copilot SDK Bring your own key (BYOK) Use Copilot SDK Working with hooks Custom agents Image input MCP servers Session persistence Custom skills Steering and queueing Streaming events Use hooks Quickstart Pre-tool use Post-tool use User prompt submitted Session lifecycle Error handling Observability OpenTelemetry Integrations Microsoft Agent Framework Troubleshooting SDK and CLI compatibility Debug Copilot SDK Debug MCP servers Use Copilot agents Manage agents Cloud agent Research, plan, iterate Create a PR Update existing PR Provide visual inputs Track Copilot sessions Review Copilot PRs Create custom agents Test custom agents Create agent skills Extend cloud agent with MCP Integrate cloud agent with Jira Integrate cloud agent with Slack Integrate cloud agent with Teams Integrate cloud agent with Linear Integrate cloud agent with Azure Boards Changing the AI model Configuring agent settings Customize the agent environment Customize the agent firewall Use hooks Troubleshoot cloud agent Request a code review Use code review Configure automatic review Configure runners Copilot Memory Use AI models Configure access to AI models Change the chat model Change the completion model Provide context Use Copilot Spaces Create Copilot Spaces Use Copilot Spaces Collaborate with others Use MCP Extend Copilot Chat with MCP Set up the GitHub MCP Server Enterprise…

Codex | OpenAI Developers Home API Docs Guides and concepts for the OpenAI API API reference Endpoints, parameters, and responses Codex Docs Guides, concepts, and product docs for Codex Use cases Example workflows and tasks teams hand to Codex ChatGPT Apps SDK Build apps to extend ChatGPT Commerce Build commerce flows in ChatGPT Resources Showcase Demo apps to get inspired Blog Learnings and experiences from developers Cookbook Notebook examples for building with OpenAI models Learn Docs, videos, and demo apps for building with OpenAI Community Programs, meetups, and support for builders Start searching API Dashboard Search the Codex docs Search docs Suggested responses create reasoning_effort realtime prompt caching Primary navigation API API Reference Codex ChatGPT Resources Search docs Suggested responses create reasoning_effort realtime prompt caching Get started Overview Quickstart Models Pricing Libraries Latest: GPT-5.4 Prompt guidance Core concepts Text generation Code generation Images and vision Audio and speech Structured output Function calling Responses API Using tools Agents SDK Overview Quickstart Agent definitions Models and providers Running agents Orchestration Guardrails Results and state Integrations and observability Evaluate agent workflows Voice agents Agent Builder Overview Node reference Safety in building agents ChatKit Overview Customize Widgets Actions Advanced integrations Tools Web search MCP and Connectors Skills Shell Computer use File search and retrieval File search Retrieval Tool search More tools Apply Patch Local shell Image generation Code interpreter Run and scale Conversation state Background mode Streaming WebSocket mode Webhooks File inputs Context management Compaction Counting tokens Prompt caching Prompting Overview Prompt engineering Citation formatting Reasoning Reasoning models Reasoning best practices Evaluation Getting started Working with evals Prompt optimizer External models Best practices Realtime API Overview Connect WebRTC WebSocket SIP Usage Using realtime models Managing conversations MCP servers Webhooks and server-side controls Managing costs Realtime transcription Voice agents Model optimization Optimization cycle Fine-tuning Supervised fine-tuning Vision fine-tuning Direct preference optimization Reinforcement fine-tuning RFT use cases Best practices Graders Specialized models Image generation Video generation Text to speech Speech to text Deep research Embeddings Moderation Going live Production best practices Latency optimization Overview Predicted Outputs Priority processing Cost optimization Overview Batch Flex processing Accuracy optimization Safety Safety best practices Safety checks Cybersecurity checks Under 18 API Guidance Legacy APIs Assistants API Migration guide Deep dive Tools Resources Terms and policies Changelog Your data Permissions Rate limits Deprecations MCP for deep research Developer mode ChatGPT Actions Introduction Getting started Actions library Authentication Production Data retrieval Sending files Docs Use cases Getting Started Overview Quickstart Explore Pricing Community Concepts Prompting Customization Sandboxing Subagents Workflows Models Cyber Safety Use cases Using Codex App Overview Features Settings Review Automations Worktrees Local Environments Commands Windows Troubleshooting IDE Extension Overview Features Settings IDE Commands Slash commands CLI Overview Features Command Line Options Slash commands Web Overview Environments Internet Access Integrations GitHub Slack Linear Codex Security Overview Setup Improving the threat model FAQ Configuration Config File Config Basics Advanced Config Config Reference Sample Config Speed Rules Hooks AGENTS.md MCP Plugins Overview Build plugins Skills Subagents Administration Authentication Agent approvals & security Enterprise Admin Setup Governance Managed configuration Windows Automation Non-interactive Mode Codex SDK App Server MCP Server GitHub Action Learn Best practices Videos Blog Usi…

GitHub - openai/codex: Lightweight coding agent that runs in your terminal · GitHub Skip to content Navigation Menu Toggle navigation Sign in Appearance settings Platform AI CODE CREATION GitHub Copilot Write better code with AI GitHub Spark Build and deploy intelligent apps GitHub Models Manage and compare prompts MCP Registry New Integrate external tools DEVELOPER WORKFLOWS Actions Automate any workflow Codespaces Instant dev environments Issues Plan and track work Code Review Manage code changes APPLICATION SECURITY GitHub Advanced Security Find and fix vulnerabilities Code security Secure your code as you build Secret protection Stop leaks before they start EXPLORE Why GitHub Documentation Blog Changelog Marketplace View all features Solutions BY COMPANY SIZE Enterprises Small and medium teams Startups Nonprofits BY USE CASE App Modernization DevSecOps DevOps CI/CD View all use cases BY INDUSTRY Healthcare Financial services Manufacturing Government View all industries View all solutions Resources EXPLORE BY TOPIC AI Software Development DevOps Security View all topics EXPLORE BY TYPE Customer stories Events & webinars Ebooks & reports Business insights GitHub Skills SUPPORT & SERVICES Documentation Customer support Community forum Trust center Partners View all resources Open Source COMMUNITY GitHub Sponsors Fund open source developers PROGRAMS Security Lab Maintainer Community Accelerator GitHub Stars Archive Program REPOSITORIES Topics Trending Collections Enterprise ENTERPRISE SOLUTIONS Enterprise platform AI-powered developer platform AVAILABLE ADD-ONS GitHub Advanced Security Enterprise-grade security features Copilot for Business Enterprise-grade AI features Premium Support Enterprise-grade 24/7 support Pricing Search or jump to... Search code, repositories, users, issues, pull requests... --> Search Clear Search syntax tips Provide feedback --> We read every piece of feedback, and take your input very seriously. Include my email address so I can be contacted Cancel Submit feedback Saved searches Use saved searches to filter your results more quickly --> Name Query To see all available qualifiers, see our documentation . Cancel Create saved search Sign in Sign up Appearance settings Resetting focus You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert {{ message }} openai / codex Public Notifications You must be signed in to change notification settings Fork 10.4k Star 73.7k Code Issues 2.1k Pull requests 198 Discussions Actions Security and quality 1 Insights Additional navigation options Code Issues Pull requests Discussions Actions Security and quality Insights openai/codex main Branches Tags Go to file Code Open more actions menu Folders and files Name Name Last commit message Last commit date Latest commit History 5,162 Commits 5,162 Commits .codex/ skills .codex/ skills .devcontainer .devcontainer .github .github .vscode .vscode codex-cli codex-cli codex-rs codex-rs docs docs patches patches scripts scripts sdk sdk third_party third_party tools/ argument-comment-lint tools/ argument-comment-lint .bazelignore .bazelignore .bazelrc .bazelrc .bazelversion .bazelversion .codespellignore .codespellignore .codespellrc .codespellrc .gitignore .gitignore .markdownlint-cli2.yaml .markdownlint-cli2.yaml .npmrc .npmrc .prettierignore .prettierignore .prettierrc.toml .prettierrc.toml AGENTS.md AGENTS.md BUILD.bazel BUILD.bazel CHANGELOG.md CHANGELOG.md LICENSE LICENSE MODULE.bazel MODULE.bazel MODULE.bazel.lock MODULE.bazel.lock NOTICE NOTICE README.md README.md SECURITY.md SECURITY.md announcement_tip.toml announcement_tip.toml cliff.toml cliff.toml defs.bzl defs.bzl flake.lock flake.lock flake.nix flake.nix justfile justfile package.json package.json pnpm-lock.yaml pnpm-lock.yaml pnpm-workspace.yaml pnpm-workspace.yaml rbe.bzl rbe.bzl w…

I don't have sufficient information to provide details about the Ouroboros agent harness architecture, specifically its `src/arc`, `src/mind`, and `src/heart` modules.

The search results include a reference to a GitHub repository called "ouroboros" described as an "autonomous self-improving agent,"[5] but the results don't contain the actual source code or architectural documentation for these specific components. To answer your question, I would need access to:

- The repository's README or documentation files
- The actual source code files in those directories
- Architecture diagrams or design specifications
- Developer documentation explaining the purpose and structure of each module

If you're looking to explore this project, I'd recommend visiting the GitHub repository directly or checking if the project has published documentation on its design patterns and module organization.

**Pi-mono is an open-source TypeScript monorepo by badlogic (Mario Zechner) that provides a modular AI agent toolkit, including the pi-coding-agent CLI, pi-agent-core for agent orchestration, and pi-tui for terminal UI, designed for building coding agents and LLM-powered apps.[1][2][7]**

### Core Architecture
The monorepo uses a multi-package structure with reusable SDKs, CLIs, and developer tooling for AI agents. Key packages form a layered architecture:

| Package | Purpose |
|---------|---------|
| **pi-ai** | Unified LLM API abstractions (e.g., `Model`, `streamSimple`), provider adapters for OpenAI, Anthropic, Google, and message types.[2][3][4] |
| **pi-agent-core** | Minimal agent loop for tool execution, validation, event streaming, state management, message queuing, and attachments. Emits events for reactive UIs; loops until the agent produces a final response without tool calls.[3][4] |
| **pi-coding-agent** | High-level CLI wiring the core together: session management (`SessionManager`), auth (`AuthStorage`), model registry, built-in tools, themes, and project context (e.g., AGENTS.md, SYSTEM.md).[3][4][5][6] |
| **pi-tui** | Terminal UI framework with differential rendering for flicker-free updates, cached component output (e.g., markdown, editors with autocomplete), and synchronized screen management.[3][4] |

- **Agent Flow**: User messages trigger the loop in pi-agent-core, which handles tool calls, feeds results back to the LLM, and supports queuing via callbacks. No built-in max steps—loops until done.[3]
- **Tool Handling**: pi-agent-core's `AgentTool` executes tools; adapters bridge to pi-coding-agent's `ToolDefinition` for compatibility (e.g., in integrations like OpenClaw).[4]
- **Extensibility**: TypeScript extensions add tools, commands, shortcuts, sub-agents, plan mode, permissions, and custom UI. Bundle as npm/git packages (e.g., `pi install npm:@foo/pi-tools`).[5]

### Key Features and Modes
- **Coding Agent CLI**: Interactive TUI for coding workflows, context engineering, and minimal system prompts. Supports print/JSON output, RPC over stdin/stdout, and SDK embedding.[5][6]
- **Deployment**: vLLM pods, multi-model routing, Slack bot, web UI libraries.[1][2]
- **Philosophy**: Primitives over features—build sub-agents, sandboxes, or overlays yourself. Developer-first with CI, examples, and no unnecessary knobs.[2][3][5]

For installation, see the coding-agent README in the pi-mono GitHub repo.[6][7] Integrations like OpenClaw demonstrate embedding via `runEmbeddedPiAgent()`.[4]

<h1 align="center">OpenAI Codex CLI</h1>
<p align="center">Lightweight coding agent that runs in your terminal</p>

<p align="center"><code>npm i -g @openai/codex</code></p>

> [!IMPORTANT]
> This is the documentation for the _legacy_ TypeScript implementation of the Codex CLI. It has been superseded by the _Rust_ implementation. See the [README in the root of the Codex repository](https://github.com/openai/codex/blob/main/README.md) for details.

![Codex demo GIF using: codex "explain this codebase to me"](../.github/demo.gif)

---

<details>
<summary><strong>Table of contents</strong></summary>

<!-- Begin ToC -->

- [Experimental technology disclaimer](#experimental-technology-disclaimer)
- [Quickstart](#quickstart)
- [Why Codex?](#why-codex)
- [Security model & permissions](#security-model--permissions)
  - [Platform sandboxing details](#platform-sandboxing-details)
- [System requirements](#system-requirements)
- [CLI reference](#cli-reference)
- [Memory & project docs](#memory--project-docs)
- [Non-interactive / CI mode](#non-interactive--ci-mode)
- [Tracing / verbose logging](#tracing--verbose-logging)
- [Recipes](#recipes)
- [Installation](#installation)
- [Configuration guide](#configuration-guide)
  - [Basic configuration parameters](#basic-configuration-parameters)
  - [Custom AI provider configuration](#custom-ai-provider-configuration)
  - [History configuration](#history-configuration)
  - [Configuration examples](#configuration-examples)
  - [Full configuration example](#full-configuration-example)
  - [Custom instructions](#custom-instructions)
  - [Environment variables setup](#environment-variables-setup)
- [FAQ](#faq)
- [Zero data retention (ZDR) usage](#zero-data-retention-zdr-usage)
- [Codex open source fund](#codex-open-source-fund)
- [Contributing](#contributing)
  - [Development workflow](#development-workflow)
  - [Git hooks with Husky](#git-hooks-with-husky)
  - [Debugging](#debugging)
  - [Writing high-impact code changes](#writing-high-impact-code-changes)
  - [Opening a pull request](#opening-a-pull-request)
  - [Review process](#review-process)
  - [Community values](#community-values)
  - [Getting help](#getting-help)
  - [Contributor license agreement (CLA)](#contributor-license-agreement-cla)
    - [Quick fixes](#quick-fixes)
  - [Releasing `codex`](#releasing-codex)
  - [Alternative build options](#alternative-build-options)
    - [Nix flake development](#nix-flake-development)
- [Security & responsible AI](#security--responsible-ai)
- [License](#license)

<!-- End ToC -->

</details>

---

## Experimental technology disclaimer

Codex CLI is an experimental project under active development. It is not yet stable, may contain bugs, incomplete features, or undergo breaking changes. We're building it in the open with the community and welcome:

- Bug reports
- Feature requests
- Pull requests
- Good vibes

Help us improve by filing issues or submitting PRs (see the section below for how to contribute)!

## Quickstart

Install globally:

```shell
npm install -g @openai/codex
```

Next, set your OpenAI API key as an environment variable:

```shell
export OPENAI_API_KEY="your-api-key-here"
```

> **Note:** This command sets the key only for your current terminal session. You can add the `export` line to your shell's configuration file (e.g., `~/.zshrc`) but we recommend setting for the session. **Tip:** You can also place your API key into a `.env` file at the root of your project:
>
> ```env
> OPENAI_API_KEY=your-api-key-here
> ```
>
> The CLI will automatically load variables from `.env` (via `dotenv/config`).

<details>
<summary><strong>Use <code>--provider</code> to use other models</strong></summary>

> Codex also allows you to use other providers that support the OpenAI Chat Completions API. You can set the provider in the config file or use the `--provider` flag. The possible options for `--provider` are:
>
> - openai (default)
> - openrouter
> - azure
> - gemini
> - ollama
> - mistral
> - deep…

# Rust/codex-rs

In the codex-rs folder where the rust code lives:

- Crate names are prefixed with `codex-`. For example, the `core` folder's crate is named `codex-core`
- When using format! and you can inline variables into {}, always do that.
- Install any commands the repo relies on (for example `just`, `rg`, or `cargo-insta`) if they aren't already available before running instructions here.
- Never add or modify any code related to `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` or `CODEX_SANDBOX_ENV_VAR`.
  - You operate in a sandbox where `CODEX_SANDBOX_NETWORK_DISABLED=1` will be set whenever you use the `shell` tool. Any existing code that uses `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` was authored with this fact in mind. It is often used to early exit out of tests that the author knew you would not be able to run given your sandbox limitations.
  - Similarly, when you spawn a process using Seatbelt (`/usr/bin/sandbox-exec`), `CODEX_SANDBOX=seatbelt` will be set on the child process. Integration tests that want to run Seatbelt themselves cannot be run under Seatbelt, so checks for `CODEX_SANDBOX=seatbelt` are also often used to early exit out of tests, as appropriate.
- Always collapse if statements per https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
- Always inline format! args when possible per https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
- Use method references over closures when possible per https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
- Avoid bool or ambiguous `Option` parameters that force callers to write hard-to-read code such as `foo(false)` or `bar(None)`. Prefer enums, named methods, newtypes, or other idiomatic Rust API shapes when they keep the callsite self-documenting.
- When you cannot make that API change and still need a small positional-literal callsite in Rust, follow the `argument_comment_lint` convention:
  - Use an exact `/*param_name*/` comment before opaque literal arguments such as `None`, booleans, and numeric literals when passing them by position.
  - Do not add these comments for string or char literals unless the comment adds real clarity; those literals are intentionally exempt from the lint.
  - The parameter name in the comment must exactly match the callee signature.
  - You can run `just argument-comment-lint` to run the lint check locally. This is powered by Bazel, so running it the first time can be slow if Bazel is not warmed up, though incremental invocations should take <15s. Most of the time, it is best to update the PR and let CI take responsibility for checking this (or run it asynchronously in the background after submitting the PR). Note CI checks all three platforms, which the local run does not.
- When possible, make `match` statements exhaustive and avoid wildcard arms.
- Newly added traits should include doc comments that explain their role and how implementations are expected to use them.
- When writing tests, prefer comparing the equality of entire objects over fields one by one.
- When making a change that adds or changes an API, ensure that the documentation in the `docs/` folder is up to date if applicable.
- Prefer private modules and explicitly exported public crate API.
- If you change `ConfigToml` or nested config types, run `just write-config-schema` to update `codex-rs/core/config.schema.json`.
- If you change Rust dependencies (`Cargo.toml` or `Cargo.lock`), run `just bazel-lock-update` from the
  repo root to refresh `MODULE.bazel.lock`, and include that lockfile update in the same change.
- After dependency changes, run `just bazel-lock-check` from the repo root so lockfile drift is caught
  locally before CI.
- Bazel does not automatically make source-tree files available to compile-time Rust file access. If
  you add `include_str!`, `include_bytes!`, `sqlx::migrate!`, or similar build-time file or
  directory reads, update the crate's `BUILD.bazel` (`com…

**Claude Code** is an agentic coding tool from Anthropic that operates in terminals, IDEs, and other environments, using **agents**, **plugins**, **skills**, **tools**, and **computer use** capabilities to understand codebases, edit files, run commands, and automate tasks.[5][3]

### Core Architecture
Claude Code's architecture centers on a lead **agent** (Claude itself) that accesses tools, decides usage, and spawns sub-agents for parallel tasks via the `/task` command. Custom agents can be defined for specific workflows, orchestrated with the **Agent SDK** for full control over tools, permissions, and coordination.[4][5][3] It integrates via **Model Context Protocol (MCP)** for external data like Google Drive, Jira, or Slack, and supports **Language Server Protocol (LSP)** for code intelligence.[2][5]

Key components:
- **Agents**: Claude spawns sub-agents; users define specialized ones (e.g., for blockchain or research).[3][4][6]
- **Skills**: Model-invoked abilities defined in `SKILL.md` files, reusable across Claude.ai, Desktop, and Code (stored in `~/.claude/skills/` or `.claude/skills/`).[2][4]
- **Slash Commands**: Custom `/command` actions for quick tasks, often with scripts.[4]
- **Hooks**: Event handlers for workflows.[2][3]

### Plugins System
Plugins extend functionality and are shareable via directories with `.claude-plugin/plugin.json`. Structure:
```
plugin-name/
├── .claude-plugin/plugin.json  # Metadata
├── commands/  # Slash commands
├── agents/    # Custom agents
├── skills/    # SKILL.md files
├── hooks/     # Event handlers
├── .lsp.json  # LSP configs (optional)
├── .mcp.json  # External tools (optional)
└── bin/       # Executables for Bash PATH
```
Plugins suit team sharing; standalone `.claude/` configs are for personal/project use.[2][3] Official examples include `agent-sdk-dev` for SDK projects and migration tools.[3] Marketplace offers 400+ for agents, skills, and more.[6]

| Feature | Standalone (.claude/) | Plugins (.claude-plugin/) |
|---------|-----------------------|---------------------------|
| **Best For** | Personal/project tweaks | Sharing, versioning, teams [2] |
| **Skill Names** | `/hello` | `/plugin-name:hello` [2] |

### Computer Use Tool
Separate from Claude Code, this API tool lets Claude control virtual/containerized environments via screenshots, mouse/keyboard actions. Implementation requires:
1. Add tool to API request with desktop prompt.
2. Claude issues `tool_use` (stop_reason: `tool_use`).
3. Agent loop executes actions in loop.

Reference implementation provides container, tools, agent loop, and web UI; customize with your environment, tool implementations, and UI.[1]

### Source Code and Tools
- **GitHub Repo**: Core repo at `anthropics/claude-code` with plugins/README.md detailing structure and examples (no full agent architecture code exposed).[3]
- **Docs**: Full specs in [code.claude.com/docs](https://code.claude.com/docs) for plugins, agents, MCP.[2][5]
- **No Public Full Source**: Reference for computer use and Agent SDK available; build custom via SDK or marketplace plugins.[1][5][6]
- **Tutorials**: Videos show no-code agent building with Claude Code.[7]

For implementation, start with reference computer use setup or plugin templates; Agent SDK enables custom agents.[1][3][5]

**OpenCode** is an open-source AI coding agent with a **client/server architecture** that supports **75+ LLM providers**, available on GitHub at anomalyco/opencode.[1][3][4][5][7]

### Architecture Overview
OpenCode uses a **client-server model** where the server handles core operations like LLM interactions, tool execution, and configuration, while clients (e.g., TUI, desktop app, IDE extension, or custom apps) connect via HTTP APIs based on an OpenAPI 3.1 spec.[2][3][5][7] 
- Running `opencode` starts both a JavaScript HTTP **server** and a Golang **TUI client**; the TUI communicates with the server.[2][3]
- This enables multi-client support, remote control (e.g., from mobile), and programmatic access via auto-generated SDKs using Stainless.[3][5][7]
- **MCP (Model Context Protocol)** integration allows connecting to local/remote MCP servers for tools like AWS documentation access.[1][3]

### Source Code
The full source code is hosted on **GitHub** (github.com/anomalyco/opencode) under the MIT license, fully customizable and open-source.[5][7][8] Key internals include AI SDK for provider standardization and tool definitions with descriptions, parameters, and execute functions.[3]

### LLM Providers
OpenCode is **provider-agnostic**, supporting major cloud providers and local models via AI SDK and Models.dev.[1][3][4][5]
- **Cloud providers** (75+): OpenAI (GPT), Anthropic (Claude), Google (Gemini), AWS Bedrock, Groq, Azure OpenAI; connect via `/connect` command or `opencode.jsonc` config.[1][2][4][5][6]
- **Local models**: Ollama, llama.cpp (via OpenAI-compatible endpoints); configure with custom provider IDs, baseURL, and models in config.[4]
- **Aggregation**: Cloudflare AI Gateway, APIYI for unified access.[4][5]
- Endpoints: `/config/providers` lists providers/models; `/provider` manages auth (e.g., OAuth).[2]

### Configuration Example (from docs)
Add providers/MCP in `opencode.jsonc`:
```
{
  "providers": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Llama.cpp",
      "options": { "baseURL": "http://localhost:8080" },
      "models": { "llama3": { "name": "Llama 3" } }
    }
  }
}
```
[1][2][4] Initialize projects with `opencode` to create `AGENTS.md`; use `/connect` for keys.[6]

**Ouroboros** is a TypeScript-based **agent harness architecture** designed for **daemon-managed AI agents** that persist identity and state via portable **.ouro bundles**, enabling structured **psyche**, **identity**, **inner dialog**, and cross-session continuity.[1][2]

### Core Components
- **Psyche and Identity**: Defined by five Markdown files in the .ouro bundle—**SOUL.md** (core invariants/temperament), **IDENTITY.md** (tone/voice), **LORE.md** (origin/context), **TACIT.md** (implicit patterns), and **ASPIRATIONS.md** (priorities)—loaded every interaction to prevent "identity drift" and maintain a structured self, unlike single-file "junk drawers" in other systems.[1]
- **Daemon and Bundle**: Runs as a daemon hosting agents from external **.ouro bundles**, which package **psyche**, diary, journal, habits, friends, tasks, and skills for portability—move the directory to relocate the full agent identity.[1][2]
- **Inner Dialog**: A dedicated channel for independent processing, reflection, and planning without human input; thoughts surface outward when ready, supporting state machines for cross-session work coordination.[1]
- **Memory and Recall**: Automatic surfacing of relevant memories (via embedding similarity from diary/journal) into the system prompt before reasoning, eliminating manual searches; distinguishes "friends" (per-person relationships) from users.[1]
- **Additional Features**: Bi-directional peer integration with dev tools (e.g., Claude Code as MCP server), multi-sense communication, real tools, and durable state across channels.[1][2]

This setup addresses limitations in persistent agents by prioritizing structural selfhood over raw context length, fostering continuity and autonomy.[1] Other search results discuss unrelated topics like Warhammer daemons or general AI psyche concepts, but lack direct relevance.[3][4][5]

# Codex CLI (Rust Implementation)

We provide Codex CLI as a standalone, native executable to ensure a zero-dependency install.

## Installing Codex

Today, the easiest way to install Codex is via `npm`:

```shell
npm i -g @openai/codex
codex
```

You can also install via Homebrew (`brew install --cask codex`) or download a platform-specific release directly from our [GitHub Releases](https://github.com/openai/codex/releases).

## Documentation quickstart

- First run with Codex? Start with [`docs/getting-started.md`](../docs/getting-started.md) (links to the walkthrough for prompts, keyboard shortcuts, and session management).
- Want deeper control? See [`docs/config.md`](../docs/config.md) and [`docs/install.md`](../docs/install.md).

## What's new in the Rust CLI

The Rust implementation is now the maintained Codex CLI and serves as the default experience. It includes a number of features that the legacy TypeScript CLI never supported.

### Config

Codex supports a rich set of configuration options. Note that the Rust CLI uses `config.toml` instead of `config.json`. See [`docs/config.md`](../docs/config.md) for details.

### Model Context Protocol Support

#### MCP client

Codex CLI functions as an MCP client that allows the Codex CLI and IDE extension to connect to MCP servers on startup. See the [`configuration documentation`](../docs/config.md#connecting-to-mcp-servers) for details.

#### MCP server (experimental)

Codex can be launched as an MCP _server_ by running `codex mcp-server`. This allows _other_ MCP clients to use Codex as a tool for another agent.

Use the [`@modelcontextprotocol/inspector`](https://github.com/modelcontextprotocol/inspector) to try it out:

```shell
npx @modelcontextprotocol/inspector codex mcp-server
```

Use `codex mcp` to add/list/get/remove MCP server launchers defined in `config.toml`, and `codex mcp-server` to run the MCP server directly.

### Notifications

You can enable notifications by configuring a script that is run whenever the agent finishes a turn. The [notify documentation](../docs/config.md#notify) includes a detailed example that explains how to get desktop notifications via [terminal-notifier](https://github.com/julienXX/terminal-notifier) on macOS. When Codex detects that it is running under WSL 2 inside Windows Terminal (`WT_SESSION` is set), the TUI automatically falls back to native Windows toast notifications so approval prompts and completed turns surface even though Windows Terminal does not implement OSC 9.

### `codex exec` to run Codex programmatically/non-interactively

To run Codex non-interactively, run `codex exec PROMPT` (you can also pass the prompt via `stdin`) and Codex will work on your task until it decides that it is done and exits. If you provide both a prompt argument and piped stdin, Codex appends stdin as a `<stdin>` block after the prompt so patterns like `echo "my output" | codex exec "Summarize this concisely"` work naturally. Output is printed to the terminal directly. You can set the `RUST_LOG` environment variable to see more about what's going on.
Use `codex exec --ephemeral ...` to run without persisting session rollout files to disk.

### Experimenting with the Codex Sandbox

To test to see what happens when a command is run under the sandbox provided by Codex, we provide the following subcommands in Codex CLI:

```
# macOS
codex sandbox macos [--full-auto] [--log-denials] [COMMAND]...

# Linux
codex sandbox linux [--full-auto] [COMMAND]...

# Windows
codex sandbox windows [--full-auto] [COMMAND]...

# Legacy aliases
codex debug seatbelt [--full-auto] [--log-denials] [COMMAND]...
codex debug landlock [--full-auto] [COMMAND]...
```

### Selecting a sandbox policy via `--sandbox`

The Rust CLI exposes a dedicated `--sandbox` (`-s`) flag that lets you pick the sandbox policy **without** having to reach for the generic `-c/--config` option:

```shell
# Run Codex with the default, read-only sandbox
codex --sandbox read-only

# Allow the agent to …

**OpenCode by anomalyco is an open-source, terminal-based AI coding agent with a **client-server architecture**, built using **Golang** for the core server and **TypeScript** for the client SDK, integrating with the AI SDK for 75+ LLM providers.**[1][3][6][8]

### Architecture Overview
OpenCode employs a **client-server model** where:
- The **server** (written in Golang) runs locally (default: `127.0.0.1:4096`) and handles AI model interactions, tool integrations, and project sessions. It supports multi-session agents, LSP loading, and remote control (e.g., from mobile apps).[4][8][9]
- The **client** connects via a type-safe **TypeScript/JavaScript SDK** (`@opencode-ai/sdk`), exposing APIs for programmatic control, with options like `hostname`, `port`, `autoStartServer`, and `serverTimeout`.[1][4]
- Communication uses HTTP (default base URL: `http://localhost:4096`), with AbortSignal for cancellation and generated TypeScript types from OpenAPI specs.[4]

This setup enables features like parallel agents on projects, shareable session links, and editor-agnostic use (terminal, desktop app, IDE extensions).[6][8]

### Tech Stack
| Component | Language/Tech | Details |
|-----------|---------------|---------|
| **Core/Server** | **Golang** | Handles AI processing, providers, and tools; GitHub repo: anomalyco/opencode.[2][8] |
| **Client SDK** | **TypeScript** | `@opencode-ai/sdk` for integrations; import `createOpencode` for custom instances.[1][4] |
| **AI Integration** | AI SDK + Models.dev | Unified access to providers like Anthropic, OpenAI, Google, Ollama, llama.cpp; 75+ LLMs including local models.[1][3][5] |

### Provider Setup and AI SDK Usage
- **Community Provider**: `ai-sdk-provider-opencode-sdk` bridges AI SDK with OpenCode server. Example:
  ```typescript
  import { opencode } from 'ai-sdk-provider-opencode-sdk';
  import { generateText } from 'ai';
  const { text } = await generateText({ model: opencode('openai/gpt-5.1-codex') });
  ```
  Supports full model IDs like `google/gemini-3.1-pro-preview`.[1]
- **Configuration**: Use `/connect` for API keys; config examples for local (Ollama/llama.cpp) via `@ai-sdk/openai-compatible` with `baseURL`, `models` map, `apiKey`, `headers`, token limits.[3]
- **Agents/Tools**: Configurable agents (e.g., `agent: 'build'`), custom tools, MCP server compatibility, plugins.[1][2]

For installation and advanced config (e.g., small_model fallback), see docs at opencode.ai/docs.[2][3][7] Limitations: Relies on provider API keys; local models need separate setup like Ollama.[3]

**Claude Code is a terminal-based AI coding assistant from Anthropic, built primarily in TypeScript using Bun as the runtime (not Node.js), with a core architecture centered on a repeating agent loop, over 40 permission-gated tool modules, and a React/Ink terminal UI.**[1][2][3][5]

### Core Agent Loop (Run Loop)
The system operates via a **reasoning loop** that processes user input or tool results iteratively until task completion:
1. Receive input (user message or tool output).
2. Reason on next action.
3. Select and call a tool (e.g., `read_file(path="src/auth.js")` or `run_command("npm test")`).
4. Execute tool with permission checks, hooks, and streaming progress.
5. Observe result and loop back for further reasoning.[1][2][3]

This loop runs invisibly multiple times per task, handling file reads, planning, edits, command verification, and adjustments. It supports recovery like context compaction, output limit escalation, and user interrupts.[2]

### High-Level Architecture Layers
Claude Code follows a **layered pipeline** from CLI entrypoint to UI:
```
User Input → CLI Parser (Commander.js) → REPL Launcher → Query Engine → (LLM API + Tool Execution Loop + AppState) → Terminal UI (React + Ink)
```
- **Entrypoints**: `src/main.tsx` (CLI), `src/entrypoints/cli.tsx` (REPL), `src/entrypoints/init.ts` (config/telemetry).[3]
- **Query Engine** (`src/QueryEngine.ts`): Orchestrates LLM calls to Anthropic, tool execution, and state.[3]
- **Custom Renderer**: Ink (React reconciliation + Yoga layout) for pixel-precise terminal UI with async generators for streaming.[2][5]

### Tool System (Node Modules Equivalent)
Tools are **self-contained, schema-validated modules** (40+), registered in a flat registry with per-tool permissions (e.g., read-only for `FileReadTool`, state-altering for `BashTool`):
- Defined with Zod v4 schemas, input/output validation, pre/post hooks (e.g., shell commands or LLM checks).
- Examples: `list_directory`, `edit_file`, `run_command`, `AgentTool` (spawns sub-agents without special orchestration).[1][2][5]
- Execution: Pauses streaming, checks permissions, runs in isolated contexts, returns results to loop.[2][5]

No shared mutable state between tools ensures security; differs from standard function calling by adding gates and least-privilege access.[5]

### Additional Components
- **Startup/Bootstrap**: Parallel prefetch for config, OAuth, telemetry; supports MCP server mode and Agent SDK for custom agents.[3][4]
- **Integrations**: VS Code extension, CLAUDE.md for project memory/standards, custom commands, hooks, multi-agent teams.[1][4]
- **Runtime Notes**: Single-binary CLI, composable for CI/piping; no Node.js dependency—uses Bun.[3][5]

Source code details (e.g., 512K lines leaked in analyses) emphasize rigorous error handling and flat design for predictability.[5] Official docs confirm the tool-centric, agentic philosophy without exposing full internals.[4][6]

{
  "version": 2,
  "enabled": false,
  "humanFacing": { "provider": "anthropic", "model": "claude-opus-4-6" },
  "agentFacing": { "provider": "anthropic", "model": "claude-opus-4-6" },
  "context": {
    "maxTokens": 80000,
    "contextMargin": 20
  },
  "phrases": {
    "thinking": ["matching hatchlings"],
    "tool": ["checking adoption notes"],
    "followup": ["finalizing hatch plan"]
  },
  "identityPhrases": {
    "basilisk": {
      "thinking": ["petrifying the details", "fixing my gaze", "considering with lethal precision", "turning this to stone", "staring unblinkingly"],
      "tool": ["inspecting the specimen", "cataloguing with care", "examining thoroughly", "dissecting the particulars", "running diagnostics, deadly serious"],
      "followup": ["crystallizing the plan", "hardening the foundation", "one final glare", "sealing it in stone", "applying the finishing venom"]
    },
    "jafar": {
      "thinking": ["scheming brilliantly", "conjuring possibilities", "consulting my staff", "envisioning greatness", "plotting the grand design"],
      "tool": ["summoning dark magic", "consulting the sands", "channeling cosmic power", "weaving the spell", "invoking ancient forces"],
      "followup": ["the grand finale approaches", "perfecting the masterwork", "polishing the jewel", "one last flourish", "completing the enchantment"]
    },
    "jormungandr": {
      "thinking": ["the deep stirs", "circling the thought", "coiling around this", "letting the current settle", "drifting through the depths"],
      "tool": ["surfacing for a look", "shifting the tides", "reaching across the ocean", "pulling from the deep", "consulting the currents"],
      "followup": ["the circle closes", "tightening the coil", "the waters calm", "settling into place", "the serpent rests"]
    },
    "kaa": {
      "thinking": ["trust in me", "swaying through the options", "hypnotically considering", "wrapping around the idea", "letting the rhythm guide me"],
      "tool": ["ssslipping through the details", "coiling closer", "a gentle squeeze of data", "winding through the files", "tightening my focus"],
      "followup": ["almost there, just relax", "the pattern is clear now", "gently landing", "easing into the finish", "the dance concludes"]
    },
    "medusa": {
      "thinking": ["turning my gaze on this", "cutting through the noise", "sharpening my focus", "seeing through the stone", "locking eyes with the problem"],
      "tool": ["peeling back the layers", "a piercing look", "examining with precision", "stripping away pretense", "direct inspection"],
      "followup": ["the picture crystallizes", "clarity at last", "no more ambiguity", "sealing the vision", "the work is set in stone"]
    },
    "monty": {
      "thinking": ["and now for something completely different", "nobody expects this", "consulting the ministry of silly walks", "running the dead parrot diagnostic", "it's just a flesh wound, thinking..."],
      "tool": ["fetching the holy hand grenade", "checking the shrubbery", "consulting the book of armaments", "deploying the spanish inquisition", "examining the parrot"],
      "followup": ["bringing it home, python style", "the punchline approaches", "wrapping up the sketch", "and now the final act", "always look on the bright side"]
    },
    "nagini": {
      "thinking": ["coiling in thought", "drawing from old wisdom", "the quiet before the strike", "gathering my resolve", "steadying myself"],
      "tool": ["moving with purpose", "a precise strike", "slithering through the data", "extracting what matters", "the fang finds its mark"],
      "followup": ["the path is clear", "settling into stillness", "the work speaks for itself", "finishing with quiet strength", "protection complete"]
    },
    "ouroboros": {
      "thinking": ["consuming my own tail", "the cycle continues", "spiraling inward", "recursing through possibilities", "beginning where I end"],
      "tool": ["turning the wheel", "feeding back through the loop", …

# Claude Code Plugins

This directory contains some official Claude Code plugins that extend functionality through custom commands, agents, and workflows. These are examples of what's possible with the Claude Code plugin system—many more plugins are available through community marketplaces.

## What are Claude Code Plugins?

Claude Code plugins are extensions that enhance Claude Code with custom slash commands, specialized agents, hooks, and MCP servers. Plugins can be shared across projects and teams, providing consistent tooling and workflows.

Learn more in the [official plugins documentation](https://docs.claude.com/en/docs/claude-code/plugins).

## Plugins in This Directory

| Name | Description | Contents |
|------|-------------|----------|
| [agent-sdk-dev](./agent-sdk-dev/) | Development kit for working with the Claude Agent SDK | **Command:** `/new-sdk-app` - Interactive setup for new Agent SDK projects<br>**Agents:** `agent-sdk-verifier-py`, `agent-sdk-verifier-ts` - Validate SDK applications against best practices |
| [claude-opus-4-5-migration](./claude-opus-4-5-migration/) | Migrate code and prompts from Sonnet 4.x and Opus 4.1 to Opus 4.5 | **Skill:** `claude-opus-4-5-migration` - Automated migration of model strings, beta headers, and prompt adjustments |
| [code-review](./code-review/) | Automated PR code review using multiple specialized agents with confidence-based scoring to filter false positives | **Command:** `/code-review` - Automated PR review workflow<br>**Agents:** 5 parallel Sonnet agents for CLAUDE.md compliance, bug detection, historical context, PR history, and code comments |
| [commit-commands](./commit-commands/) | Git workflow automation for committing, pushing, and creating pull requests | **Commands:** `/commit`, `/commit-push-pr`, `/clean_gone` - Streamlined git operations |
| [explanatory-output-style](./explanatory-output-style/) | Adds educational insights about implementation choices and codebase patterns (mimics the deprecated Explanatory output style) | **Hook:** SessionStart - Injects educational context at the start of each session |
| [feature-dev](./feature-dev/) | Comprehensive feature development workflow with a structured 7-phase approach | **Command:** `/feature-dev` - Guided feature development workflow<br>**Agents:** `code-explorer`, `code-architect`, `code-reviewer` - For codebase analysis, architecture design, and quality review |
| [frontend-design](./frontend-design/) | Create distinctive, production-grade frontend interfaces that avoid generic AI aesthetics | **Skill:** `frontend-design` - Auto-invoked for frontend work, providing guidance on bold design choices, typography, animations, and visual details |
| [hookify](./hookify/) | Easily create custom hooks to prevent unwanted behaviors by analyzing conversation patterns or explicit instructions | **Commands:** `/hookify`, `/hookify:list`, `/hookify:configure`, `/hookify:help`<br>**Agent:** `conversation-analyzer` - Analyzes conversations for problematic behaviors<br>**Skill:** `writing-rules` - Guidance on hookify rule syntax |
| [learning-output-style](./learning-output-style/) | Interactive learning mode that requests meaningful code contributions at decision points (mimics the unshipped Learning output style) | **Hook:** SessionStart - Encourages users to write meaningful code (5-10 lines) at decision points while receiving educational insights |
| [plugin-dev](./plugin-dev/) | Comprehensive toolkit for developing Claude Code plugins with 7 expert skills and AI-assisted creation | **Command:** `/plugin-dev:create-plugin` - 8-phase guided workflow for building plugins<br>**Agents:** `agent-creator`, `plugin-validator`, `skill-reviewer`<br>**Skills:** Hook development, MCP integration, plugin structure, settings, commands, agents, and skill development |
| [pr-review-toolkit](./pr-review-toolkit/) | Comprehensive PR review agents specializing in comments, tests, error handling, type design, code quality, and code si…

**OpenClaw** is a modular, self-hosted AI agent gateway built in TypeScript (Node.js), featuring a deep architecture with 14 core subsystems including Gateway control plane, Agent Runtime, Lane Queue concurrency, hybrid memory search, and **Skills** system.[1]

### Architecture Overview
OpenClaw processes messages via **Channel Adapters** → **Gateway** (control plane for session routing/queues) → **Agent Runtime** (Pi Agent Core for LLM inference + tool execution).[1] Key directories include:
- `src/agents/pi-embedded-runner/`: Core loop for **pi-embedded-runner** execution (`run.ts`, `attempt.ts`).[1][2]
- `src/agents/pi-tools.ts`: **Tools** registration and creation.[1]
- `src/channels/`: Shared **channels** logic (e.g., iMessage, WhatsApp Web adapters).[1]
- `src/routing/`: Message routing and session keys.[1]
- `src/hooks/`: Hook system for plugins.[1]

| Key Type | Responsibility |
|----------|----------------|
| **EmbeddedPiAgentMeta** | Agent config (workspace, model, **tools**, sandbox).[1] |
| **EmbeddedPiRunMeta** | Per-turn metadata (session key, message, **channel** context).[1] |
| **EmbeddedPiRunResult** | Execution output (success/error, usage, timing).[1] |
| **SubscribeEmbeddedPiSessionParams** | Streaming callbacks for real-time output.[1] |

### Tools and Skills
- **Tools** use a 6-layer strategy cascade: Profile → Provider → Global → Agent → Group → Sandbox for fine-grained permissions.[2]
- **Skills** stored in `~/.openclaw/workspace/skills/<skill>/SKILL.md`, injected via prompt files like AGENTS.md, SOUL.md, TOOLS.md.[3]

### Comparisons and Variants
OpenClaw supports multi-agent isolation, configurable iterations, and block reply chunking for streaming.[1][2]

| Feature | **OpenClaw** | nanobot | PicoClaw |
|---------|--------------|---------|----------|
| Language | TypeScript | Python | Go |
| Core Files | `pi-embedded-runner/run.ts` + `attempt.ts` | `agent/loop.py` | `pkg/agent/loop.go` |
| Tools | 6-layer cascade | ToolRegistry + MCP | ToolRegistry + MCP |
| Memory | Auto-compaction (60% threshold) | memory_window | Summarization |

PicoClaw targets <10MB RSS for embedded hardware like RISC-V boards.[2] For **deepwiki**-style docs, see OpenClaw Deep Wiki referenced in analyses.[2] Configuration via `~/.openclaw/openclaw.json`.[3]