codex-harness — The Thread-Native Team-Architecture Factory for Codex

English | 한국어

codex-harness is a team-architecture factory for OpenAI Codex. Say "build a harness for this project" (English) or "하네스 구성해줘" (한국어), and the skill turns your domain description into an Orchestrator Thread + specialist Agent Threads and the reusable skills they use — picked from six pre-defined team-architecture patterns and emitted onto Codex-native surfaces only.

Overview

codex-harness decomposes complex, recurring work into a coordinated team of specialized agents — but where the original revfactory/harness maps that team onto Claude Code's agent-team runtime, codex-harness maps it onto the surface Codex actually runs on: the Codex Thread.

A Thread is treated as the first-class execution boundary — a durable specialist room with its own isolated context, role identity, and handoff report. The harness scaffolds these threads, the skills they run, and the file-mediated state that lets them hand work to each other. Point it at a project, ask it to "build a harness," and it generates everything on Codex surfaces only — AGENTS.md, .agents/skills/, .agents/agents/, .codex/config.toml, Codex Threads, codex exec, sandbox/approval policy, MCP, and optional hooks. No .claude/, no CLAUDE.md, no Claude-specific orchestration tools.

Category — Where codex-harness Sits

codex-harness lives at the L3 Meta-Factory layer — the layer that generates other harnesses rather than being one. Inside L3 it occupies the Team-Architecture Factory sub-layer, the same one as revfactory/harness, but bound to a different runtime.

Layer	What it does	Runtime
L3 — Meta-Factory / Team-Architecture Factory (us)	Domain sentence → Orchestrator Thread + Agent Threads + skills, via 6 team patterns	OpenAI Codex (Threads)
L3 — Meta-Factory / Team-Architecture Factory	Same concept, Claude-native agent teams	revfactory/harness
L3 — Meta-Factory / Runtime-Configuration Factory	Deterministic, repeatable runtime configurations	coleam00/Archon

revfactory/harness generates Claude-Code agent teams. codex-harness generates the same six team architectures (pipeline, fan-out/fan-in, expert pool, producer-reviewer, supervisor, hierarchical delegation) plus the skills agents use — but as Codex Threads with file-mediated handoff. Same sub-layer, different runtime. Pick revfactory/harness for Claude Code, codex-harness for Codex.

Key Features

• Thread-Native Team Design — 6 architectural patterns (Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation) mapped onto an Orchestrator Thread + Agent Threads.
• Expert-Level Roles, Not Generic Doers — Every agent role must encode professional judgment: expert heuristics, decision rules, anti-patterns, domain quality bars, and (for research roles) a search/query strategy. The harness asks you at consequential decision points instead of assuming.
• Skill Generation — Auto-generates reusable skills with Progressive Disclosure (references/, templates/, scripts/) for efficient context management.
• File-Mediated Orchestration — _workspace/ carries thread briefs, handoff reports, merge inputs, and decisions across sessions, making threads durable and partial reruns possible.
• Codex-Native Safety — Risk is bounded by sandbox/profile/hook policy and config.toml profiles, not by prose alone.
• Validation — Trigger verification, dry-run scenarios, thread-board checks, and integration-coherence checks.

Workflow

Phase 0: Audit existing harness
    ↓
Phase 1: Domain & recurring-work analysis  →  _workspace/00_requirements.md
    ↓
Phase 2: Execution-mode selection (smallest useful runtime)
    ↓
Phase 3: Architecture-pattern selection (6 patterns)
    ↓
Phase 4: Agent role definition          →  .agents/agents/<role>.md
    ↓
Phase 5: Skill generation               →  .agents/skills/<skill>/SKILL.md
    ↓
Phase 6: Orchestrator skill generation  →  .agents/skills/<domain>-orchestrator/
    ↓
Phase 7: Thread workspace               →  _workspace/
    ↓
Phase 8: AGENTS.md pointer update
    ↓
Phase 9: Optional Codex automation (codex exec / hooks / MCP)
    ↓
Phase 10: Validation
    ↓
Phase 11: Evolution

How the Mapping Works

codex-harness preserves the Harness concept but supplies the runtime mapping Codex needs. The best Codex port is not "Claude agent team → codex exec scripts." It is "Claude agent team → Codex Thread team + file-mediated handoff + optional codex exec automation + optional subagents + optional hooks."

Harness concept	Claude-native implementation	Codex thread-native implementation
Orchestrator	Team / manager agent	Orchestrator Thread
Specialist agent	.claude/agents + team messaging	Agent Thread + role file + skill
Message protocol	SendMessage / TaskCreate	Thread briefs + handoff reports
Shared state	Team task state	_workspace/ + thread board
Parallelism	Agent/team runtime	Multiple Codex Threads or codex exec jobs
Review gates	Team protocol + QA agents	Phase gates in the Orchestrator Thread
Evolution	/harness:evolve	Harness maintenance + change history

Installation

The skill lives at skills/harness/. Install it where Codex discovers skills — globally for all projects, or per-project.

Global (all projects)

git clone https://github.com/namojo/codex-harness.git
mkdir -p ~/.agents/skills
cp -r codex-harness/skills/harness ~/.agents/skills/harness

Or keep it updatable with a symlink:

git clone https://github.com/namojo/codex-harness.git ~/codex-harness
ln -s ~/codex-harness/skills/harness ~/.agents/skills/harness
# update later with: git -C ~/codex-harness pull

Per-project

mkdir -p .agents/skills
cp -r /path/to/codex-harness/skills/harness .agents/skills/harness

After installing, confirm Codex can see it — skills/harness/SKILL.md carries the frontmatter name: harness.

Repository Structure

codex-harness/
├── README.md
├── LICENSE
└── skills/
    └── harness/
        ├── SKILL.md                 # Main skill (12-phase, Phase 0–11)
        ├── templates/
        │   ├── thread-brief.md       # Copy-paste prompt for an Agent Thread
        │   └── thread-report.md      # Standardized handoff report
        ├── examples/
        │   └── newsletter-thread-harness.md
        └── references/
            ├── codex-thread-native-architecture.md      # Threads as agent runtime
            ├── codex-thread-orchestration-protocol.md   # board, brief, report, gates
            ├── codex-agent-patterns-thread-native.md    # 6 patterns, thread-mapped
            ├── codex-orchestrator-template-thread-native.md
            ├── codex-native-surfaces.md                 # sandbox, config.toml, exec, MCP
            ├── codex-expertise-and-quality.md           # expert judgment, query strategy, gate rubrics
            ├── codex-skill-writing-guide.md
            └── codex-skill-testing-guide.md

Usage

In a Codex session, ask in natural language. Triggering phrases include:

Build a harness for this project
Design a thread-native orchestrator and specialist agent threads for this workflow
Convert this recurring workflow into a Codex multi-thread harness
Design an agent team / subagent workflow for <domain>
Extend the harness — add a <role> agent / a <task> skill
Audit / repair / sync the harness          (maintenance mode)

The skill runs: audit → domain analysis → execution-mode selection → thread-native architecture → agent roles → skills → orchestrator → thread workspace → AGENTS.md → optional automation → validation → evolution. It reports the architecture, the files it created, validation evidence, and the copy-paste prompts you use to run the harness.

Execution Modes

The harness picks the smallest useful runtime.

Mode	Use when	Runtime shape
Single Thread	small or sequential task	one Codex Thread + skills
Thread-Orchestrated Team (default)	recurring, role-separated, parallel, context-heavy work	Orchestrator Thread + Agent Threads
Hybrid Thread + codex exec	repeatable CLI checks or independent review jobs	threads coordinate, exec automates
Subagent-in-Thread	host exposes subagents and the task is bounded	agent thread uses subagents internally
Scheduled Harness	recurring unattended read-only work	external scheduler + codex exec + _workspace/

Default to Thread-Orchestrated Team when the user explicitly asks for multi-agent, multi-thread, orchestrator, team, fan-out/fan-in, or harness behavior.

Architecture Patterns

Pattern	Description	Thread-native mapping
Pipeline	Sequential dependent tasks	phase-by-phase Threads/skills run in order
Fan-out/Fan-in	Parallel independent tasks	parallel Agent Threads; Orchestrator merges reports
Expert Pool	Context-dependent selective invocation	spawn a specialist Thread only when needed
Producer-Reviewer	Generation followed by quality review	separate authoring Thread from review Thread
Supervisor	Central agent, dynamic task distribution	Orchestrator spawns new briefs as it explores
Hierarchical Delegation	Top-down recursive delegation	sub-orchestrator Threads manage sub-teams

Output

Files generated by codex-harness (artifact bodies are written in Korean by default — name frontmatter, code, paths, and settled technical terms stay as-is):

your-project/
├── AGENTS.md                 # routing rule, thread orchestration, safety policy, change history
├── .agents/
│   ├── agents/               # durable specialist role definitions
│   │   ├── analyst.md
│   │   ├── builder.md
│   │   └── reviewer.md
│   └── skills/               # reusable skills (the "how")
│       ├── <domain>-orchestrator/
│       │   └── SKILL.md       # Orchestrator Thread skill: brief, gate, merge, evolve
│       └── <task>/
│           ├── SKILL.md
│           └── references/
└── _workspace/               # file-mediated handoff state
    ├── 00_requirements.md
    ├── 01_thread_board.md
    ├── 02_thread_briefs/
    ├── 03_thread_reports/
    ├── 04_merge_inputs/
    └── 90_decisions.md

Use Cases — Try These Prompts

Copy any prompt below into a Codex session after installing codex-harness:

Deep Research

Build a harness for deep research. I need an Orchestrator Thread that fans out
to specialist Agent Threads — web search, academic sources, community sentiment —
then cross-validates findings through a review gate and merges a cited report.

Website Development

Build a harness for full-stack website development. The team should handle
design, frontend (React/Next.js), backend (API), and QA in a coordinated
pipeline of threads, handing off through _workspace/ from wireframe to deploy.

Newsletter / Content Production

Build a thread-native harness for a weekly newsletter: research, drafting,
editing, and fact-check threads that hand off through _workspace/, with the
Orchestrator Thread gating each phase before publish.

Code Review & Refactoring

Build a harness for comprehensive code review. I want parallel Agent Threads
checking architecture, security, performance, and style, plus codex exec jobs
for independent read-only audits — then merged into a single report.

Technical Documentation

Build a harness that generates API documentation from this codebase. Threads
should analyze endpoints, write descriptions, generate usage examples, and run
a completeness review gate before merge.

Recurring Ops / Scheduled Harness

Convert this recurring read-only check into a scheduled harness: an external
scheduler runs codex exec jobs, writes results into _workspace/, and an
Orchestrator Thread reviews the board on demand.

Why Thread-Native, Not Just codex exec

• Codex Threads are execution boundaries. A thread can be a durable specialist room with isolated context, role identity, and a handoff report.
• The Orchestrator is a thread. It owns decomposition, routing, phase gates, merge decisions, partial reruns, and evolution.
• File-mediated state makes threads durable. _workspace/ carries thread briefs, reports, merge inputs, and decisions across sessions.
• codex exec is an automation spine, not the whole runtime. Use it for independent reviews, structured extraction, read-only audits, and batch checks.
• Safety is enforced, not described. Each automated step's risk is bounded by sandbox/profile/hook policy. Durable roles map to config.toml profiles, external tools register as MCP servers, and AGENTS.md is used hierarchically.

Coexistence — codex-harness and Neighbors

Repo	Their position	Relationship to codex-harness
revfactory/harness	Team-Architecture Factory on Claude Code	Same sub-layer, different runtime. codex-harness is the Codex Thread-native edition of this concept. Use harness on Claude Code, codex-harness on Codex.
coleam00/Archon	Deterministic runtime-configuration factory	Same L3, neighbor sub-layer. Archon for runtime determinism, codex-harness for thread-team architecture, or combine them.

FAQ

Q1. How is this different from just writing codex exec scripts?

A. A pile of codex exec scripts has no durable context, no role identity, and no handoff protocol. codex-harness treats each Codex Thread as a specialist room with its own context and a standardized handoff report, coordinated by an Orchestrator Thread through _workspace/. codex exec is still used — as an automation spine for independent reviews, structured extraction, and read-only audits — but it supports the threads rather than replacing them.

Q2. Is this a fork of revfactory/harness?

A. It's a Codex-native port of the concept, not a fork of the implementation. It keeps the six team-architecture patterns, the skill-generation craft, and the validate/evolve loop, but emits Codex surfaces only (AGENTS.md, .agents/, Codex Threads, codex exec, sandbox/approval policy, MCP, hooks) and adds the runtime mapping in the table above. It never produces .claude/, CLAUDE.md, or Claude-specific orchestration tools.

Q3. Do I always get a multi-thread team?

A. No. The harness picks the smallest useful runtime — a small or sequential task gets a Single Thread. It only builds an Orchestrator + Agent Threads when there's genuine role separation, parallelism, independent review, long context, or recurrence. See the Execution Modes table.

License

MIT — see LICENSE. Concept adapted from revfactory/harness.

---

한국어

English | 한국어

codex-harness는 OpenAI Codex를 위한 팀 아키텍처 팩토리입니다. "하네스 구성해줘" 또는 **"build a harness for this project"**라고 말하면, 스킬이 도메인 설명을 Orchestrator Thread + 전문 Agent Threads와 그들이 사용할 재사용 스킬로 바꿔 줍니다 — 6가지 사전 정의된 팀 아키텍처 패턴 중에서 선택하며, Codex 네이티브 표면에만 생성합니다.

개요

codex-harness는 복잡하고 반복적인 업무를 전문 에이전트 팀으로 분해합니다. 다만 원본인 revfactory/harness가 그 팀을 Claude Code의 에이전트 팀 런타임에 매핑하는 반면, codex-harness는 Codex가 실제로 동작하는 표면인 Codex Thread에 매핑합니다.

Thread는 1급 실행 단위로 취급됩니다 — 독립된 맥락, 역할 정체성, 핸드오프 보고를 가진 durable한 전문 작업실입니다. 하네스는 이 스레드들, 그 안에서 실행할 스킬, 그리고 스레드끼리 작업을 주고받게 해 주는 파일 매개 상태를 스캐폴딩합니다. 프로젝트를 가리키며 "하네스 만들어줘"라고 하면, 모든 것을 Codex 표면(AGENTS.md, .agents/skills/, .agents/agents/, .codex/config.toml, Codex Threads, codex exec, 샌드박스/승인 정책, MCP, 선택적 hooks)에만 생성합니다. .claude/, CLAUDE.md, Claude 전용 오케스트레이션 도구는 만들지 않습니다.

카테고리 — codex-harness의 위치

codex-harness는 L3 Meta-Factory 계층 — 다른 하네스를 만들어 내는 계층 — 에 있습니다. L3 안에서는 revfactory/harness와 동일한 Team-Architecture Factory 서브 계층에 속하되, 런타임이 다릅니다.

계층	하는 일	런타임
L3 — Meta-Factory / Team-Architecture Factory (우리)	도메인 문장 → Orchestrator Thread + Agent Threads + 스킬, 6가지 팀 패턴	OpenAI Codex (Threads)
L3 — Meta-Factory / Team-Architecture Factory	같은 개념, Claude 네이티브 에이전트 팀	revfactory/harness
L3 — Meta-Factory / Runtime-Configuration Factory	결정론적이고 반복 가능한 런타임 설정	coleam00/Archon

revfactory/harness는 Claude Code 에이전트 팀을 만듭니다. codex-harness는 동일한 6가지 팀 아키텍처(pipeline, fan-out/fan-in, expert pool, producer-reviewer, supervisor, hierarchical delegation)와 스킬을 만들되 파일 매개 핸드오프를 가진 Codex Thread로 구현합니다. 같은 서브 계층, 다른 런타임. Claude Code면 revfactory/harness, Codex면 codex-harness를 선택하세요.

핵심 기능

• Thread-Native 팀 설계 — 6가지 아키텍처 패턴(Pipeline, Fan-out/Fan-in, Expert Pool, Producer-Reviewer, Supervisor, Hierarchical Delegation)을 Orchestrator Thread + Agent Threads로 매핑.
• 전문가 수준 역할 (generic doer 금지) — 모든 에이전트 역할은 전문가 판단 기준을 내장한다: 전문가 휴리스틱, 의사결정 규칙, 안티패턴, 도메인 품질 기준선, (리서치 역할은) 검색·쿼리 전략. 하네스는 결과를 좌우하는 결정 지점에서 가정 대신 사용자에게 묻는다.
• 스킬 생성 — Progressive Disclosure(references/, templates/, scripts/)를 적용한 재사용 스킬을 자동 생성해 맥락을 효율적으로 관리.
• 파일 매개 오케스트레이션 — _workspace/가 thread brief, handoff report, merge input, decision을 세션 너머로 보존해 스레드를 durable하게 만들고 부분 재실행을 가능하게 함.
• Codex 네이티브 안전성 — 위험을 산문이 아니라 sandbox/profile/hook 정책과 config.toml 프로파일로 제한.
• 검증 — 트리거 검증, 드라이런 시나리오, thread-board 검증, 통합 정합성 검증.

워크플로우

Phase 0: 기존 하네스 점검
    ↓
Phase 1: 도메인·반복 업무 분석        →  _workspace/00_requirements.md
    ↓
Phase 2: 실행 모드 선택 (가장 작은 유용한 런타임)
    ↓
Phase 3: 아키텍처 패턴 선택 (6가지)
    ↓
Phase 4: Agent 역할 정의              →  .agents/agents/<role>.md
    ↓
Phase 5: 스킬 생성                    →  .agents/skills/<skill>/SKILL.md
    ↓
Phase 6: 오케스트레이터 스킬 생성     →  .agents/skills/<domain>-orchestrator/
    ↓
Phase 7: Thread workspace             →  _workspace/
    ↓
Phase 8: AGENTS.md 포인터 업데이트
    ↓
Phase 9: 선택적 Codex 자동화 (codex exec / hooks / MCP)
    ↓
Phase 10: 검증
    ↓
Phase 11: 진화

매핑 방식

codex-harness는 Harness의 개념을 유지하되 Codex에 필요한 런타임 매핑을 제공합니다. Codex용 최적 포팅은 "Claude 에이전트 팀 → codex exec 스크립트"가 아닙니다. "Claude 에이전트 팀 → Codex Thread 팀 + 파일 매개 핸드오프 + 선택적 codex exec 자동화 + 선택적 subagents + 선택적 hooks"입니다.

Harness 개념	Claude-native 구현	Codex thread-native 구현
Orchestrator	팀장/매니저 에이전트	Orchestrator Thread
Specialist agent	.claude/agents + 팀 메시징	Agent Thread + role 파일 + 스킬
Message protocol	SendMessage / TaskCreate	Thread brief + handoff report
Shared state	팀 task state	_workspace/ + thread board
Parallelism	Agent/team 런타임	여러 Codex Thread 또는 codex exec 작업
Review gate	Team protocol + QA agents	Orchestrator Thread의 phase gate
Evolution	/harness:evolve	Harness maintenance + change history

설치

스킬 본체는 skills/harness/에 있습니다. Codex가 스킬을 인식하는 위치에 설치하세요 — 모든 프로젝트면 전역, 특정 프로젝트만이면 프로젝트별로 설치합니다.

전역 설치 (모든 프로젝트)

git clone https://github.com/namojo/codex-harness.git
mkdir -p ~/.agents/skills
cp -r codex-harness/skills/harness ~/.agents/skills/harness

업데이트를 쉽게 유지하려면 심볼릭 링크 방식:

git clone https://github.com/namojo/codex-harness.git ~/codex-harness
ln -s ~/codex-harness/skills/harness ~/.agents/skills/harness
# 이후 업데이트: git -C ~/codex-harness pull

프로젝트별 설치

mkdir -p .agents/skills
cp -r /path/to/codex-harness/skills/harness .agents/skills/harness

설치 후 Codex가 인식하는지 확인하세요 — skills/harness/SKILL.md에 frontmatter name: harness가 있습니다.

저장소 구조

codex-harness/
├── README.md
├── LICENSE
└── skills/
    └── harness/
        ├── SKILL.md                 # 메인 스킬 (12단계, Phase 0–11)
        ├── templates/
        │   ├── thread-brief.md       # Agent Thread에 붙여넣는 지시문
        │   └── thread-report.md      # 표준 핸드오프 보고서
        ├── examples/
        │   └── newsletter-thread-harness.md
        └── references/
            ├── codex-thread-native-architecture.md      # Thread를 agent runtime으로
            ├── codex-thread-orchestration-protocol.md   # board, brief, report, gate
            ├── codex-agent-patterns-thread-native.md    # 6패턴, thread 매핑
            ├── codex-orchestrator-template-thread-native.md
            ├── codex-native-surfaces.md                 # sandbox, config.toml, exec, MCP
            ├── codex-expertise-and-quality.md           # expert judgment, query strategy, gate rubrics
            ├── codex-skill-writing-guide.md
            └── codex-skill-testing-guide.md

사용법

Codex 세션에서 자연어로 요청합니다. 트리거되는 표현 예시:

이 프로젝트에 하네스 만들어줘
이 워크플로우를 위한 thread-native orchestrator와 specialist agent thread를 설계해줘
이 반복 업무를 Codex multi-thread harness로 바꿔줘
<도메인>을 위한 에이전트 팀 / 서브에이전트 워크플로우 설계해줘
하네스 확장해줘 — <역할> 에이전트 / <작업> 스킬 추가
하네스 점검 / 수정 / 동기화해줘          (유지보수 모드)

스킬은 감사 → 도메인 분석 → 실행 모드 선택 → thread-native architecture → 에이전트 역할 → 스킬 → 오케스트레이터 → thread workspace → AGENTS.md → 선택적 자동화 → 검증 → 진화 순으로 동작합니다. 아키텍처, 생성한 파일, 검증 근거, 그리고 하네스를 실행할 때 붙여 넣을 프롬프트를 보고합니다.

실행 모드

하네스는 가장 작은 유용한 런타임을 선택합니다.

모드	언제 쓰나	Runtime shape
Single Thread	작고 순차적인 작업	하나의 Codex Thread + skills
Thread-Orchestrated Team (기본값)	반복적, 역할 분리, 병렬, 긴 맥락 작업	Orchestrator Thread + Agent Threads
Hybrid Thread + codex exec	반복 CLI 검사나 독립 리뷰	조율은 thread, 자동화는 exec
Subagent-in-Thread	host가 subagent를 제공하고 작업이 bounded일 때	agent thread 내부에서 subagent 사용
Scheduled Harness	반복되는 unattended read-only 작업	외부 scheduler + codex exec + _workspace/

사용자가 multi-agent, multi-thread, orchestrator, team, fan-out/fan-in, harness를 명시하면 기본값은 Thread-Orchestrated Team입니다.

아키텍처 패턴

패턴	설명	Thread-native 매핑
Pipeline	순차 의존 작업	phase별 Thread/스킬을 순서대로 실행
Fan-out/Fan-in	병렬 독립 작업	여러 Agent Thread 병렬 실행, Orchestrator가 보고 병합
Expert Pool	맥락 의존 선택적 호출	필요할 때만 전문가 Thread 생성
Producer-Reviewer	생성 후 품질 리뷰	작성 Thread와 리뷰 Thread 분리
Supervisor	중앙 에이전트가 동적 배분	Orchestrator가 탐색 중 새 brief를 동적 생성
Hierarchical Delegation	하향식 재귀 위임	sub-orchestrator Thread가 하위 팀 관리

산출물

codex-harness가 생성하는 파일 (산출물 본문은 기본 한국어로 작성 — name frontmatter, 코드, 경로, 정착된 기술 용어는 그대로 유지):

your-project/
├── AGENTS.md                 # 라우팅 규칙, 스레드 오케스트레이션, 안전 정책, 변경 이력
├── .agents/
│   ├── agents/               # 재사용 가능한 전문 역할 정의
│   │   ├── analyst.md
│   │   ├── builder.md
│   │   └── reviewer.md
│   └── skills/               # 재사용 스킬 ("어떻게")
│       ├── <domain>-orchestrator/
│       │   └── SKILL.md       # Orchestrator Thread 스킬: brief, gate, merge, evolve
│       └── <task>/
│           ├── SKILL.md
│           └── references/
└── _workspace/               # 파일 매개 핸드오프 상태
    ├── 00_requirements.md
    ├── 01_thread_board.md
    ├── 02_thread_briefs/
    ├── 03_thread_reports/
    ├── 04_merge_inputs/
    └── 90_decisions.md

활용 사례 — 이 프롬프트를 써보세요

codex-harness 설치 후 Codex 세션에 아래 프롬프트를 복사해 넣어 보세요:

심층 리서치

심층 리서치용 하네스를 만들어줘. 웹 검색, 학술 자료, 커뮤니티 반응을 담당하는
Agent Thread로 fan-out하고, 리뷰 게이트로 교차 검증한 뒤 인용이 달린 보고서를
병합하는 Orchestrator Thread가 필요해.

웹사이트 개발

풀스택 웹사이트 개발 하네스를 만들어줘. 디자인, 프론트엔드(React/Next.js),
백엔드(API), QA를 스레드 파이프라인으로 조율하고, 와이어프레임부터 배포까지
_workspace/를 통해 핸드오프하게 해줘.

뉴스레터 / 콘텐츠 제작

주간 뉴스레터용 thread-native 하네스를 만들어줘: 리서치, 초안, 편집, 팩트체크
스레드가 _workspace/를 통해 핸드오프하고, Orchestrator Thread가 발행 전 각 phase를
게이트로 통과시키게 해줘.

코드 리뷰 & 리팩터링

종합 코드 리뷰 하네스를 만들어줘. 아키텍처, 보안, 성능, 스타일을 점검하는 병렬
Agent Thread와, 독립적인 read-only 감사를 위한 codex exec 작업을 두고 — 하나의
보고서로 병합해줘.

기술 문서화

이 코드베이스에서 API 문서를 생성하는 하네스를 만들어줘. 엔드포인트 분석, 설명
작성, 사용 예시 생성을 스레드로 나누고, 병합 전 완전성 리뷰 게이트를 거치게 해줘.

반복 운영 / 스케줄 하네스

이 반복 read-only 점검을 스케줄 하네스로 바꿔줘: 외부 scheduler가 codex exec
작업을 돌려 결과를 _workspace/에 쓰고, Orchestrator Thread가 필요할 때 board를
검토하게 해줘.

왜 단순 codex exec가 아니라 Thread-Native인가

• Codex Thread가 실행 경계입니다. 각 thread는 독립 맥락, 역할 정체성, handoff report를 가진 durable한 전문 작업실이 될 수 있습니다.
• 오케스트레이터도 thread입니다. 작업 분해, 라우팅, phase gate, merge decision, partial rerun, evolution을 맡습니다.
• 파일 매개 상태가 thread를 durable하게 만듭니다. _workspace/가 thread brief, report, merge input, decision을 세션 너머로 보존합니다.
• codex exec는 자동화 spine이지 전체 런타임이 아닙니다. 독립 리뷰, 구조화 추출, read-only audit, batch check에 사용합니다.
• 안전은 설명이 아니라 정책으로 강제합니다. 자동화 단계의 위험을 sandbox/profile/hook 정책으로 제한합니다. 재사용 역할은 config.toml 프로파일에 매핑하고, 외부 도구는 MCP 서버로 등록하며, AGENTS.md는 계층적으로 사용합니다.

공존 — codex-harness와 이웃들

저장소	위치	codex-harness와의 관계
revfactory/harness	Claude Code의 Team-Architecture Factory	같은 서브 계층, 다른 런타임. codex-harness는 이 개념의 Codex Thread-native 에디션. Claude Code면 harness, Codex면 codex-harness.
coleam00/Archon	결정론적 런타임 설정 팩토리	같은 L3, 이웃 서브 계층. 런타임 결정론은 Archon, 스레드 팀 아키텍처는 codex-harness, 또는 둘을 조합.

FAQ

Q1. 그냥 codex exec 스크립트를 짜는 것과 뭐가 다른가요?

A. codex exec 스크립트 더미에는 durable한 맥락도, 역할 정체성도, 핸드오프 규약도 없습니다. codex-harness는 각 Codex Thread를 독립 맥락과 표준 handoff report를 가진 전문 작업실로 취급하고, Orchestrator Thread가 _workspace/를 통해 조율합니다. codex exec는 여전히 — 독립 리뷰, 구조화 추출, read-only audit의 자동화 spine으로 — 쓰이지만, 스레드를 대체하지 않고 보조합니다.

Q2. revfactory/harness의 포크인가요?

A. 구현의 포크가 아니라 개념의 Codex 네이티브 포팅입니다. 6가지 팀 아키텍처 패턴, 스킬 생성 craft, 검증/진화 루프를 유지하되 Codex 표면(AGENTS.md, .agents/, Codex Threads, codex exec, 샌드박스/승인 정책, MCP, hooks)에만 생성하고, 위의 런타임 매핑을 추가합니다. .claude/, CLAUDE.md, Claude 전용 오케스트레이션 도구는 절대 만들지 않습니다.

Q3. 항상 멀티 스레드 팀이 나오나요?

A. 아닙니다. 하네스는 가장 작은 유용한 런타임을 선택합니다 — 작거나 순차적인 작업은 Single Thread로 처리합니다. 역할 분리, 병렬성, 독립 리뷰, 긴 맥락, 반복성이 실제로 있을 때만 Orchestrator + Agent Threads를 구성합니다. 실행 모드 표를 참고하세요.

라이선스

MIT — LICENSE 참조. 개념은 revfactory/harness에서 차용했습니다.