AI Agent Orchestration Platform - Where Local Intelligence Meets Autonomous Collaboration
Codex Agentic integrates Codex CLI (OpenAI's local coding agent) with Miyabi (autonomous development framework) to create a next-generation AI agent orchestration platform.
Codex CLI (Rust) + Miyabi (TypeScript)
Local Coding Agent Multi-Agent Framework
GitHub Integration
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
↓
Codex Agentic Platform
Local + Cloud Collaborative AI Agents
Issue → PR Complete Automation
Hierarchical Agent Organization
- 7 Specialized Agents: Coordinator, Issue Analysis, Code Generation, Review, PR Creation, Deployment, Testing
- Parallel Execution Engine: DAG-based dependency resolution
- 5 Organizational Principles: Clear responsibility, authority, hierarchy, results, and unambiguity
- Projects V2: Real-time progress management
- 53 Label System: State-based workflow management
- 26 GitHub Actions: Complete automation workflows
- Rust + TypeScript: Hybrid architecture
- MCP Protocol: Model Context Protocol integration
- Ratatui TUI: Beautiful terminal interface
- Issue → Code Generation → Review → PR Creation → Deployment
- Auto-documentation generation (TypeScript/JavaScript AST analysis)
- KPI dashboard & weekly report generation
# via npm (recommended)
npm install -g @openai/codex
# or Homebrew
brew install codex
# Run
codex# GitHub Issue Analysis
codex "Analyze GitHub issue #42 and suggest labels"
# Issue → PR Automation
codex "Create PR for issue #42 with automated code generation"
# Project Status Check
codex "Show GitHub project status with KPI metrics"import { Codex } from "@openai/codex-sdk";
import { MiyabiAgents } from "@openai/codex-sdk/miyabi";
const codex = new Codex();
const miyabi = new MiyabiAgents({
githubToken: process.env.GITHUB_TOKEN!,
});
// Issue analysis
const analysis = await miyabi.analyzeIssue(42);
console.log(`Labels: ${analysis.labels.join(", ")}`);
// Parallel agent execution
const result = await miyabi.runParallel({
issue: 42,
agents: ["codegen", "review", "pr"],
concurrency: 3,
});
console.log(`PR created: ${result.pr_url}`);- Integration Plan - Technical specifications and implementation guide
- Agent Operations Plan - Multi-agent collaborative operations
- Project Guide (CLAUDE.md) - Claude Code configuration
- Getting started - CLI usage
- Sandbox & approvals - Security sandbox
- Authentication - Authentication methods
- Configuration - Configuration options
- TypeScript SDK - Programmatic usage
- Advanced - MCP, tracing, etc.
- Contributing - Contribution guide
- Install & build - Build from source
- FAQ - Frequently asked questions
codex/
├── codex-rs/ # Rust core (existing)
│ ├── cli/ # Main CLI
│ ├── core/ # Business logic
│ ├── tui/ # Ratatui TUI
│ ├── exec/ # Headless execution
│ ├── mcp-client/ # MCP client
│ └── mcp-server/ # MCP server
│
├── codex-miyabi/ # Miyabi integration (new)
│ ├── packages/
│ │ ├── miyabi-mcp-server/ # MCP server implementation
│ │ ├── miyabi-agent-sdk/ # Agent SDK
│ │ ├── github-integration/ # GitHub API integration
│ │ └── doc-generator/ # Documentation generator
│ ├── agents/ # 7 specialized agents
│ └── scripts/ # Operation scripts
│
└── sdk/typescript/ # TypeScript SDK (existing)
└── src/miyabi/ # Miyabi API wrapper (new)
Codex CLI (Rust)
↓
Codex Core
↓
MCP Client ─────[MCP Protocol]────→ Miyabi MCP Server
↓
┌─────────┴─────────┐
CoordinatorAgent GitHub API
↓
┌─────────┴─────────┐
IssueAgent CodeGenAgent ReviewAgent
↓
PRAgent
🔴 Coordinator Layer (Decision Authority)
└─ CoordinatorAgent
├─ Task decomposition
├─ Agent selection
└─ Execution monitoring
🔵 Specialist Layer (Execution Authority)
├─ IssueAgent # Issue analysis & labeling
├─ CodeGenAgent # Code generation
├─ ReviewAgent # Code review
├─ PRAgent # PR creation
├─ DeploymentAgent # Deployment management
├─ TestAgent # Test execution
└─ GitHubAgent # GitHub operations
🟢 Support Layer (Assistance)
└─ DocAgent # Documentation generation
# Issue Analysis (IssueAgent)
codex "Analyze issue #42"
# → Auto-label with 53 label system
# → Determine priority, type, and phase
# Code Generation (CodeGenAgent)
codex "Generate code for issue #42"
# → Task decomposition
# → Dependency analysis
# → Code generation
# Quality Review (ReviewAgent)
codex "Review PR #123"
# → Static analysis (ESLint/Clippy)
# → Security scanning
# → Quality scoring (0-100)
# Parallel Execution (CoordinatorAgent)
codex "Process issue #42 with all agents in parallel"
# → DAG-based dependency resolution
# → Parallel execution (max 3 concurrent)
# → Result aggregation# Single command
codex "Process GitHub issue openai/codex#42 from analysis to PR"
# Internal flow:
# 1. IssueAgent: Analyze & label
# 2. CoordinatorAgent: Task decomposition
# 3. CodeGenAgent: Code generation (parallel)
# 4. ReviewAgent: Code review (parallel)
# 5. PRAgent: Create draft PR
# 6. TUI: Real-time progress display# Generate documentation from TypeScript/JavaScript code
codex "Generate API documentation for ./src directory"
# Output:
# - API.md (Markdown)
# - Training materials (for AI)
# - GitHub Discussions post# GitHub Projects V2 status check
codex "Show project status for 'Codex Development'"
# TUI display:
# ┌─────────────────────────────┐
# │ Codex Development Status │
# ├─────────────────────────────┤
# │ ⏳ Pending: 5 issues │
# │ ⚡ In Progress: 3 issues │
# │ 🔍 Review: 2 issues │
# │ ✅ Done: 42 issues │
# │ │
# │ 📊 Quality Score: 85/100 │
# │ 🧪 Coverage: 83% │
# └─────────────────────────────┘# ~/.codex/config.toml
[[mcp_servers]]
name = "miyabi"
command = "node"
args = [
"/path/to/codex/codex-miyabi/packages/miyabi-mcp-server/dist/index.js"
]
env = {
GITHUB_TOKEN = "ghp_xxx",
ANTHROPIC_API_KEY = "sk-ant-xxx"
}[miyabi]
enabled = true
monthly_budget_usd = 500
[miyabi.thresholds]
warning = 0.8 # 80% warning
emergency = 1.5 # 150% emergency stop
[miyabi.agents]
parallel_concurrency = 3
default_agents = ["issue", "codegen", "review", "pr"]Codex CLI executes all commands in a sandboxed environment:
- macOS: Seatbelt (Apple Sandbox)
- Linux: Landlock LSM
Details: Sandbox & approvals
Miyabi integration enables automatic:
- Gitleaks: Secret scanning
- CodeQL: Vulnerability detection
- npm audit: Dependency checking
- SBOM Generation: CycloneDX format
# Rust part
cd codex-rs
cargo build --release
# TypeScript part
cd codex-miyabi
pnpm install
pnpm run build
# All
pnpm run build# Rust
cd codex-rs
cargo test --all-features
# TypeScript
cd codex-miyabi
pnpm run test
# Coverage
pnpm run test:coverage- Rust:
cargo fmt -- --config imports_granularity=Item - TypeScript: ESM format, Conventional Commits
- Details: CLAUDE.md
| Component | Language | Crates/Packages |
|---|---|---|
| Codex Core | Rust | 35+ crates |
| Miyabi Integration | TypeScript | 7 packages |
| Agents | TypeScript | 7 agents |
| Feature | Codex CLI | + Miyabi |
|---|---|---|
| Local Coding | ✅ | ✅ |
| TUI | ✅ | ✅ (enhanced) |
| MCP Client | ✅ | ✅ |
| MCP Server | ✅ | ✅ (Miyabi) |
| GitHub Integration | ✅ Complete | |
| Multi-Agent | ❌ | ✅ |
| Auto-Documentation | ❌ | ✅ |
| Projects V2 | ❌ | ✅ |
External contributions are primarily accepted for bug fixes and security fixes.
For new features or behavior changes, please create an issue first and get approval from OpenAI team members. Unapproved contributions may be closed if they don't align with the roadmap.
Details: CONTRIBUTING.md
- Create an Issue (or comment on existing)
- Create feature branch:
git checkout -b feature/amazing-feature - Commit changes (Conventional Commits)
- Run tests & linting
- Create Pull Request
All contributors must accept the CLA:
I have read the CLA Document and I hereby sign the CLA
Copyright 2025 OpenAI
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Copyright 2025 Shunsuke Hayashi
Licensed under the Apache License, Version 2.0 (the "License").
This work includes Derivative Works based on:
- Codex CLI by OpenAI (Apache-2.0)
- Autonomous-Operations (Miyabi) by Shunsuke Hayashi (MIT)
Modification Notice: This repository is a derivative work that integrates Miyabi (autonomous development framework) into OpenAI's Codex CLI.
Modified files:
README.md- Updated for integration projectpnpm-workspace.yaml- Added Miyabi packagesCLAUDE.md- Added Miyabi integration notes- New additions:
codex-miyabi/,INTEGRATION_PLAN_MIYABI.md,AGENTS_OPERATION_PLAN.md
Original work's attribution and license are preserved in the LICENSE file.
This project builds upon:
- OpenAI - Codex CLI development
- Anthropic - Claude AI
- Organizational Design Principles - Agent architecture foundation
- Rust Community - Ratatui, Tokio, and other dependencies
- TypeScript Community - All dependencies
- Open Source Community - All contributors
- Codex CLI: https://github.com/openai/codex
- Miyabi (Autonomous-Operations): https://github.com/ShunsukeHayashi/Miyabi
- OpenAI Developers: https://developers.openai.com/codex
- npm Package: https://www.npmjs.com/package/@openai/codex
- Documentation: https://docs.anthropic.com/ (Claude Code)
🌸 Codex Agentic - Where AI Agents Collaborate
"Where Local Intelligence Meets Cloud Collaboration"
Generated: 2025-10-10 Version: 0.1.0 (Miyabi Integration) Based on: Codex CLI + Autonomous-Operations (Miyabi)