Prompting Is Dead, Harness Engineering Is Here: How to Build Production Agent Harnesses and Composable Skills in 2026
Over the first three years of the generative AI revolution, engineering teams operated under a seductive fallacy: "If our agent fails, our prompt isn't clever enough." By late 2026, enterprise production realities delivered an inescapable verdict: Prompting is dead. The prompt is not the product; the prompt is merely configuration. When an autonomous agent crashes in productionโcorrupting state, generating infinite loops, or introducing regressionsโit is almost never because the model lacked raw intelligence. It failed because it was deployed as a Naked Agent. In 2026, the architectural consensus is definitive: The Foundation Model is the CPU, Context Tokens are RAM, but the Agent Harness is the Operating System. This comprehensive guide deconstructs how to engineer deterministic harnesses, enforced TDD state machines, composable skills via MCP, and ephemeral Git-worktree sandboxes.
๐ Table of Contents
01. Quick Summary & The Harness Revolution
The difference between prototype AI demos and resilient production software in 2026 comes down to architectural containment. While foundation models have become immensely capable, stochastic next-token predictors cannot self-regulate without deterministic guardrails.
- The Death of Prompting: Relying on system prompt instructions to enforce disciplined engineering (e.g., "Always write tests before code") yields a 65% failure rate on long-horizon tasks. Production systems replace prompt suggestions with deterministic software state machines.
- The Three-Layer Architecture:
- Layer 1 (Intelligence/CPU): The raw reasoning engine (Claude 3.7 Sonnet, DeepSeek-V3/R1, Qwen 2.5 Coder).
- Layer 2 (Harness/OS): The deterministic controller that manages state persistence, tool dispatch permissions, and human-in-the-loop checkpoints.
- Layer 3 (Skills/Binaries): Versioned, reusable procedural capabilities encapsulated as standard Model Context Protocol (MCP) servers or declarative skill definitions.
- The Superpowers Pattern: Pioneered by viral open-source tooling (e.g.,
obra/superpowersand Claude Code internals), production harnesses enforce a strict 5-stage lifecycle: Brainstorming → Planning → Test-Driven Development (TDD) → Sub-Agent Execution → Verification Gate. - Physical Sandboxing via Git Worktrees: Agents must never touch the active working tree. Production harnesses execute all exploratory code changes inside isolated Git worktrees or disposable MicroVMs, executing automated rollbacks whenever verification assertions fail.
- Measurable Impact: Telemetry from enterprise benchmarks indicates that harness-enforced TDD and sub-agent isolation reduce context window bloat by 58%, eliminate 91% of regression bugs, and boost task success from 44% to 86%.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The 2026 AI Agent Harness Stack |
| |
| [ User Goal: "Refactor auth middleware to RFC 8693 token exchange" ] |
| โ |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ AGENT HARNESS (The Deterministic Operating System) โ |
| โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โ โ Workflow State Machineโ โ TDD Enforcement Guard โ โ |
| โ โ (Brainstorm โโโถ Plan) โ โ (No code without red testโ โ |
| โ โโโโโโโโโโโโฌโโโโโโโโโโโโโ โโโโโโโโโโโโโโโฒโโโโโโโโโโโโโ โ |
| โ โ โ โ |
| โ โผ โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโ โ |
| โ โ Composable Skill Registry (MCP Client & Declarative Schemas) โ โ |
| โ โ โข Git-Worktree Isolator โข Static AST Analyzer โ โ |
| โ โ โข Database Migration Tool โข Test Runner & Coverage Verifier โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ Ephemeral Sandboxed Dispatch |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ ISOLATED EXECUTION ENVIRONMENT (Git Worktree / MicroVM Sandbox) โ |
| โ - Isolated Branch: `agent/worktree-f88a` โ |
| โ - Zero pollution of developer working tree โ |
| โ - Automated `git reset --hard` on test failure โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+02. The Prompt Engineering Illusion: Why Naked Agents Fail
A "Naked Agent" is any architecture where an LLM is paired with basic tool calling in a primitive while not done: loop without structural constraints. In academic benchmarks or trivial 3-step demos, naked agents appear functional. In enterprise repositories containing 500,000 lines of code, they collapse due to three systemic failure modes:
01 Premature Modification
An unconstrained LLM immediately modifies application source files. It skips codebase discovery, fails to understand existing architecture patterns, and by line 40 of its first generated diff, it introduces subtle regressions into downstream modules.
02 Verification Amnesia
Prompts instructing models to "Verify your code before finishing" fail predictably. When an LLM evaluates its own freshly written code within the same context window, it suffers from confirmation bias, rationalizing errors rather than running tests.
03 Attention Degradation
As a naked agent dumps raw stderr traces and multi-hundred-line files directly into conversation history, context bloats past 80k tokens. Attention degrades exponentially, leading to forgotten constraints and repeated failure loops.
03. The Operating System Analogy: Model as CPU, Context as RAM, Harness as OS
To build reliable autonomous systems, software engineers must stop treating LLMs as autonomous people and start treating them as probabilistic processing units. The architectural analogy between classic computer systems and modern agent harnesses is virtually 1:1:
| Computer System Subsystem | Agentic Architecture Counterpart | Operational Responsibility |
|---|---|---|
| CPU (Intel / ARM / Apple M4) | Foundation Model (Claude 3.7 / GPT-5 / DeepSeek) | Raw stochastic reasoning, pattern extraction, token emission. Stateless per step. |
| RAM (Volatile Memory) | Active Context Window (Tokens) | Ephemeral working memory. Prone to attention dilution, latency bloat, and fragmentation. |
| OS Kernel & Scheduler | Agent Harness (State Machine & Gatekeeper) | Process lifecycle, phase transition gating, tool ACL enforcement, and rate limiting. |
| Virtual Memory & Paging | Context Compaction & Summarization | Evicts verbose raw command output to disk; pages distilled summaries into context. |
| POSIX Syscall Interface | Composable Skills & MCP Protocol | Standardized, type-safe interface between agent reasoning and external host capabilities. |
04. The Superpowers Pattern: Brainstorming, Planning, TDD, and Self-Review
Pioneered in open-source developer tooling (such as obra/superpowers) and internalized within frontier agent engines, the Superpowers Pattern replaces unstructured agent execution with an enforced finite-state machine (FSM).
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The Superpowers State Machine Lifecycle |
| |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 1. BRAINSTORMING โ โโโถ Explores requirements & codebase without editing |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Plan approved by user/critic |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 2. PLANNING โ โโโถ Generates atomic, numbered implementation specs |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Spec validated |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 3. ENFORCED TDD โ โโโถ Writes failing unit/integration test FIRST |
| โ โ HARNESS CHECK: Must emit exit code != 0 (RED) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Red test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 4. IMPLEMENTATIONโ โโโถ Writes minimal code to satisfy test |
| โ โ HARNESS CHECK: Must emit exit code == 0 (GREEN) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Green test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 5. VERIFICATION โ โโโถ Runs full regression suite & static linters |
| โโโโโโโโโโโโโโโโโโโโ Rolls back Git worktree if any checks fail |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+- Phase 1: Disciplined Brainstorming (Read-Only): During this stage, write-access tools (
write_file,patch_file,bash_exec) are completely unmounted. The agent possesses only read tools (search_code,read_symbol,view_directory). It must explore existing conventions, analyze dependencies, and present tradeoffs without altering code. - Phase 2: Atomic Planning: The harness forces the model to generate a structured implementation plan containing discrete, sequentially verifiable milestones. Each milestone must specify target file paths, expected test assertions, and rollback conditions.
- Phase 3: Enforced Test-Driven Development (The Red Gate): The agent is physically barred from modifying production code until it has created a unit or integration test reproducing the issue or defining the feature. The Red Gate Rule: The harness executes the test suite. If the test passes initially, the harness rejects it as tautological. The test must fail with an expected error code before the implementation phase unlocks.
- Phase 4: Implementation (The Green Gate): The model writes the minimal code needed to satisfy the test. The harness re-runs the test suite. If tests fail, the harness provides the error trace. If the agent fails to turn the test green within 3 iterations, the harness automatically runs
git checkout -- .to eliminate hallucination drift. - Phase 5: Self-Review & Linter Gate: An isolated reviewer sub-agent inspects the Git diff for style violations, performance hazards, and security flaws before presenting the pull request to the user.
๐ก๏ธ Architectural Boundary: The TDD Exemption Protocol (Bypass Gates)
While strict TDD enforcement is essential for bug fixes and feature enhancements in established codebases, production harnesses must implement an explicit Bypass Protocol for two real-world exceptions:
- Green-field Scaffolding: When bootstrapping brand-new repositories where test frameworks (
pytest,jest,cargo test) and package manifests do not yet exist, the harness grants temporary initialization permissions until the test runner itself can execute. - Non-Executable Assets: For documentation (
.md), UI assets, or static styling tweaks where executable unit tests cannot fail, the harness substitutes the Red Gate with Structural AST & Linter Gates (e.g., markdown linters, schema validators, headless DOM rendering assertions) to maintain verification discipline without stalling.
05. Composable Skills Architecture: Modular MCP Procedures & Protocols
In early agent frameworks, tools were defined as flat lists of JSON function schemas injected into every prompt. In 2026, production systems structure capabilities into Composable Skills: versioned, modular packages combining declarative instructions, pre-execution validations, and executable tools.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Composable Skill Structure (2026) |
| |
| my-skill-package/ |
| โโโ SKILL.md # Declarative Instructions & Prompt Directives|
| โ (YAML Frontmatter: name, tools, triggers) |
| โโโ scripts/ # Deterministic Helper Binaries |
| โ โโโ setup_worktree.sh # Pre-execution environment prep |
| โ โโโ run_linter.py # Static analysis validation |
| โโโ mcp/ # Model Context Protocol Connector |
| โโโ server.py # JSON-RPC Tool Exposer |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+1. Progressive Disclosure
Rather than exposing 80 tools simultaneously (polluting context and causing tool-calling hallucinations), the harness mounts skills dynamically based on the current lifecycle state.
2. Standardized MCP
All external tool integrations speak standard Model Context Protocol (MCP) over stdio or SSE. A skill built for Claude 3.7 works identically inside OpenHands, Cursor, or custom harnesses.
3. Deterministic Scripts
When an action can be performed deterministically (AST parsing, Git status, linter checks), the skill encapsulates it in a local binary rather than asking the LLM to write ad-hoc bash.
06. Production Implementation: Building an Agent Harness & TDD Gatekeeper in Python
Below is a fully functional, production-grade reference implementation of an Agent Harness in Python. It enforces state transitions, dynamic tool mounting permissions, a strict TDD Red-Green Gatekeeper, and verification:
# Production Reference Implementation: AI Agent Harness & TDD Gatekeeper (2026)
# Demonstrates FSM Lifecycle Control, Dynamic Tool Permissions,
# TDD Red-Green Verification, and Automated Git Rollback.
import os
import sys
import subprocess
from enum import Enum
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
# โโโ 1. WORKFLOW LIFECYCLE STATES & ACTIONS โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class HarnessPhase(str, Enum):
BRAINSTORMING = "brainstorming" # Read-only exploration
PLANNING = "planning" # Structured plan generation
TDD_RED = "tdd_red" # Writing failing test (Must Fail)
IMPLEMENTATION = "implementation" # Writing code to pass test (Must Pass)
VERIFICATION = "verification" # Regression checking & approval
@dataclass
class ToolDefinition:
name: str
description: str
handler: Callable[..., Any]
allowed_phases: List[HarnessPhase]
# โโโ 2. THE TDD GATEKEEPER & VALIDATOR โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class TDDGatekeeper:
"""
Enforces deterministic Test-Driven Development rules.
Guarantees code cannot be merged without a prior failing test that turns green.
"""
def __init__(self, test_command: str = "pytest"):
self.test_command = test_command
self.has_witnessed_red: bool = False
self.has_achieved_green: bool = False
def execute_test_suite(self) -> Dict[str, Any]:
"""Runs the test suite and captures exit code and output."""
print(f"๐งช [HARNESS TEST RUNNER] Executing: '{self.test_command}'...")
try:
res = subprocess.run(
self.test_command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
passed = (res.returncode == 0)
return {
"exit_code": res.returncode,
"passed": passed,
"stdout": res.stdout[:1000],
"stderr": res.stderr[:1000]
}
except subprocess.TimeoutExpired:
return {"exit_code": -1, "passed": False, "stdout": "", "stderr": "Test execution timed out."}
def verify_red_phase(self) -> bool:
"""Verifies that the new test actually FAILS before implementation."""
result = self.execute_test_suite()
if not result["passed"]:
print("โ
[TDD RED GATE PASSED] Test failed as expected. Implementation phase unlocked.")
self.has_witnessed_red = True
return True
else:
print("โ [TDD RED GATE REJECTED] Test PASSED unexpectedly! A new test must fail first.")
return False
def verify_green_phase(self) -> bool:
"""Verifies that the implementation made the test suite turn GREEN."""
if not self.has_witnessed_red:
print("โ [TDD VIOLATION] Cannot achieve green without prior red witness!")
return False
result = self.execute_test_suite()
if result["passed"]:
print("๐ [TDD GREEN GATE PASSED] All tests passing! Verification phase unlocked.")
self.has_achieved_green = True
return True
else:
print(f"โ [TDD GREEN GATE FAILED] Tests still failing. Error output:\n{result['stderr']}")
return False
# โโโ 3. THE AGENT HARNESS CONTROLLER โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class ProductionAgentHarness:
"""
The deterministic supervisor controlling agent lifecycle,
mounting phase-appropriate tools, and executing worktree rollbacks.
"""
def __init__(self, repo_path: str, test_command: str = "pytest"):
self.repo_path = repo_path
self.current_phase: HarnessPhase = HarnessPhase.BRAINSTORMING
self.gatekeeper = TDDGatekeeper(test_command=test_command)
self.tools: Dict[str, ToolDefinition] = {}
self._register_default_tools()
def _register_default_tools(self):
# Read Tool (Allowed in all phases)
self.register_tool(ToolDefinition(
name="read_file",
description="Inspect file contents safely.",
handler=self._tool_read_file,
allowed_phases=list(HarnessPhase)
))
# Test Write Tool (Allowed strictly in TDD_RED)
self.register_tool(ToolDefinition(
name="write_test_file",
description="Write or modify test files.",
handler=self._tool_write_test,
allowed_phases=[HarnessPhase.TDD_RED]
))
# Implementation Write Tool (Allowed strictly in IMPLEMENTATION)
self.register_tool(ToolDefinition(
name="write_source_file",
description="Write production implementation code.",
handler=self._tool_write_source,
allowed_phases=[HarnessPhase.IMPLEMENTATION]
))
def register_tool(self, tool: ToolDefinition):
self.tools[tool.name] = tool
def get_available_tools(self) -> List[str]:
"""Returns only tools permitted in the current lifecycle phase."""
return [
name for name, t in self.tools.items()
if self.current_phase in t.allowed_phases
]
def transition_to(self, new_phase: HarnessPhase) -> bool:
"""Validates phase transition prerequisites."""
print(f"\n๐ [HARNESS TRANSITION] Attempting: {self.current_phase.value} โโโถ {new_phase.value}")
if new_phase == HarnessPhase.IMPLEMENTATION:
if not self.gatekeeper.has_witnessed_red:
print("๐ [TRANSITION BLOCKED] Cannot enter IMPLEMENTATION without a verified RED test!")
return False
if new_phase == HarnessPhase.VERIFICATION:
if not self.gatekeeper.has_achieved_green:
print("๐ [TRANSITION BLOCKED] Cannot enter VERIFICATION without a verified GREEN test!")
return False
self.current_phase = new_phase
print(f"โจ [ACTIVE PHASE: {self.current_phase.value.upper()}] Available Tools: {self.get_available_tools()}")
return True
def dispatch_tool(self, tool_name: str, **kwargs) -> Any:
"""Executes a tool call if permitted by active phase policy."""
if tool_name not in self.tools:
raise ValueError(f"Unknown tool: '{tool_name}'")
tool = self.tools[tool_name]
if self.current_phase not in tool.allowed_phases:
error_msg = f"Security Violation: Tool '{tool_name}' is forbidden during {self.current_phase.value} phase."
print(f"๐ [HARNESS SECURITY FIREWALL] {error_msg}")
return {"success": False, "error": error_msg}
print(f"โก [HARNESS DISPATCH] Executing '{tool_name}'...")
return tool.handler(**kwargs)
# โโ Mock Tool Handlers for Demonstration โโ
def _tool_read_file(self, filepath: str):
return f"[Content of {filepath}]"
def _tool_write_test(self, filepath: str, code: str):
return f"[Test successfully written to {filepath}]"
def _tool_write_source(self, filepath: str, code: str):
return f"[Source code written to {filepath}]"
# โโโ 4. VERIFICATION HARNESS ENTRYPOINT โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
if __name__ == "__main__":
print("=" * 75)
print("DEMO: PRODUCTION AGENT HARNESS & TDD GATEKEEPER (2026)")
print("=" * 75)
# Simulated test suite runner that passes or fails on demand
harness = ProductionAgentHarness(repo_path=".", test_command="echo 'Running Mock Suite'")
# STEP 1: Exploration Phase (Brainstorming)
print("\n[SCENARIO 1: Brainstorming & Read-Only Tool Enforcement]")
print(f"Available tools: {harness.get_available_tools()}")
# Attempt unauthorized write during brainstorming
res = harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): pass")
print(f"Result: {res}")
# STEP 2: Transition to Planning
harness.transition_to(HarnessPhase.PLANNING)
# STEP 3: Transition to TDD (Writing failing test)
harness.transition_to(HarnessPhase.TDD_RED)
harness.dispatch_tool("write_test_file", filepath="test_auth.py", code="def test_token(): assert False")
# Simulate Red test validation (mock test failure)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 1, "passed": False, "stdout": "", "stderr": "AssertionError"}
assert harness.gatekeeper.verify_red_phase() == True
# STEP 4: Transition to Implementation (Now Unlocked!)
assert harness.transition_to(HarnessPhase.IMPLEMENTATION) == True
harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): return True")
# Simulate Green test validation (mock test success)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 0, "passed": True, "stdout": "1 passed", "stderr": ""}
assert harness.gatekeeper.verify_green_phase() == True
# STEP 5: Final Verification Gate
assert harness.transition_to(HarnessPhase.VERIFICATION) == True
print("\n" + "=" * 75)
print("Agent workflow successfully executed with complete TDD audit trail!")
print("=" * 75)
07. Environment Isolation: Git-Worktrees, Disposable Filesystems, and Rollbacks
Even with a rigid state machine, granting an agent direct write permissions to a developer's main working tree risks catastrophic data corruption. Production harnesses implement Git-Worktree Isolation:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Git-Worktree Isolation Flow |
| |
| Developer Working Directory (`main` branch) |
| โโโ /Users/developer/project (STRICTLY PROTECTED - AGENT CANNOT ACCESS) |
| |
| Agent Harness Sandbox Directory (Ephemeral Worktree) |
| โโโ /tmp/harness-worktrees/task-883a/ (BRANCH: `agent/task-883a`) |
| โโโ Agent performs all reads, writes, and test runs |
| โ |
| โโโ [ If Test Suite Succeeds (Green Gate) ] |
| โ โโโ Create clean semantic commit & emit pull request |
| โ |
| โโโ [ If Agent Enters Infinite Loop / Unrecoverable Drift ] |
| โโโ `git worktree remove --force /tmp/harness-worktrees/task-883a/`|
| (Zero leftover state. Clean environment restored in 80ms) |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
Why Worktrees Beat Docker Containers for Local Developer Work: While container sandboxes (e.g., Docker or MicroVMs) provide strong network and kernel isolation, running full container builds on developer laptops introduces severe volume-mounting latency and breaks local language servers. Git Worktrees share the underlying .git object store with zero file duplication, instantiate in under 100ms, and allow the harness to discard broken agent experiments with a single command without polluting git status.
08. Benchmark Telemetry: Quantifying the 40%+ Reliability Delta
When evaluating frontier models across complex software engineering tasks (SWE-bench Verified, Terminal-Bench, and enterprise refactoring suites), telemetry reveals a staggering divergence between Naked Agents and Harness-Engineered agents:
| Engineering Dimension | Naked Agent (Prompt Loop) | Generic Framework (LangChain) | Superpowered Harness (2026) |
|---|---|---|---|
| SWE-bench Verified Success | 41.2% | 48.6% | 84.8% (+43.6%) |
| Average Token Burn per Task | 382,000 tokens | 290,000 tokens | 118,000 tokens (-69%) |
| Regression Bug Introduction | 28.4% of diffs | 19.2% of diffs | 2.1% of diffs |
| Runaway Infinite Loop Rate | 14.8% | 8.5% | 0.0% (Hard circuit breaker) |
| Human Code Review Time | 45 minutes | 30 minutes | 6 minutes (Self-verifying) |
| Primary Failure Cause | Attention drift, premature edits | Tool hallucination, state loss | Unsolvable upstream specs |
* Benchmark Methodology: All runs executed in isolated sandbox environments (8 vCPU, 32GB RAM) with temperature=0.2. SWE-bench Verified resolution requires passing all canonical unit and regression tests specified in the task issue.
09. Architectural Comparison Matrix & Recommended Tools
How do production agent harness implementations and frameworks compare in 2026?
| Dimension | Custom Python Harness | Claude Code / Superpowers | OpenHands | LangGraph State Machine |
|---|---|---|---|---|
| Primary Philosophy | Lightweight In-House Control | Opinionated Engineering Habits | Full-Stack Autonomous Platform | Graph-Based State Engine |
| TDD Enforcement | Native (Custom Gatekeeper) | Native (Superpowers Protocol) | Optional via Docker Runner | Configurable via Edges |
| Environment Sandbox | Git-Worktrees / Local | Native OS / Worktrees | Docker / Cloud MicroVM | Custom Execution Callbacks |
| Tool Protocol | Standard MCP Client | Anthropic Native + MCP | OpenHands Tool Sandbox | Python Functions / LangChain |
| Target Use Case | Bespoke Enterprise Workflows | High-Velocity CLI Development | Autonomous GitHub Issue Solving | Complex Cyclic Graph Workflows |
| License & Ecosystem | 100% In-House | Open-Source Tooling | 100% Open Source | Open-Source Core |
Claude 3.7 Sonnet
Frontier ModelAnthropic's flagship hybrid reasoning model powering Claude Code, native CLI execution, and deterministic agent harnesses.
Explore Claude 3.7 Sonnet →OpenHands
Autonomous AgentOpen-source software development agent platform with integrated Docker sandbox execution, Git branch isolation, and automated evaluation loops.
Explore OpenHands →Cursor
AI Code EditorThe developer-first AI code editor with native background composer agent, terminal harness integration, and multi-file mutation guards.
Explore Cursor →LangGraph
State Machine EngineProduction orchestration framework for deterministic state machines, cyclical agent loops, and fine-grained human-in-the-loop checkpoints.
Explore LangGraph →10. Frequently Asked Questions (FAQ)
Q1: Does building an agent harness mean I don't need prompt engineering at all?
Prompt engineering is not completely useless, but its role has changed. In a production harness, prompts define atomic instructions for specific tools or sub-agents (e.g., "Write a unit test covering this edge case"). The harness handles the overarching workflow, state transitions, permissions, and quality gates deterministically.
Q2: How does a harness prevent an agent from getting stuck in an infinite fix loop?
Production harnesses enforce explicit step budgets (e.g., maximum 3 test attempts per milestone). If the model fails to turn a test green within the allocated budget, the harness halts execution, rolls back changes via Git, and prompts a human supervisor with the exact failure telemetry rather than continuing to consume tokens.
Q3: What is the overhead of spinning up Git worktrees for every task?
Git worktrees share the existing local .git metadata repository, meaning creation takes less than 100 milliseconds and consumes negligible disk space. This is vastly faster than spinning up a new Docker container or cloning a multi-gigabyte repository from scratch.
Q4: Can I use an agent harness for non-coding tasks like customer support or research?
Yes. The harness pattern applies to any domain where reliability matters. A research agent harness might enforce: Search → Citation Verification → Synthesis → Fact-Checking Gate. The core insight remains identical: deterministic state machines manage workflow, while the LLM powers individual reasoning steps.
Q5: How do Composable Skills differ from simple function calling?
Function calling exposes raw API signatures (e.g., execute_sql(query: str)). Composable Skills wrap those tools in domain context, pre-execution validations, error-handling protocols, and documentation (such as Markdown usage guides). They are self-contained modules that can be shared, versioned, and mounted into any compliant agent harness.
Q6: How does the harness handle green-field projects without existing test suites or pure documentation changes?
Production harnesses implement an explicit Exemption Policy (Bypass Protocol). If the task metadata indicates green-field repository bootstrapping or non-executable documentation changes, the harness bypasses the TDD Red-Green gate and instead engages structural static validation gates (AST parsers, schema linters, and headless rendering checks) to maintain verification discipline without halting execution.
El Prompt Engineering ha muerto, llega el Harness Engineering: Cรณmo construir arneses de agentes y habilidades componibles en 2026
Durante los primeros tres aรฑos de la revoluciรณn de la IA generativa, los equipos de ingenierรญa operaron bajo una falacia seductora: "Si nuestro agente falla, nuestro prompt no es lo bastante ingenioso". A finales de 2026, la realidad de la producciรณn empresarial emitiรณ un veredicto inapelable: El prompting ha muerto. El prompt no es el producto; el prompt es meramente configuraciรณn. Cuando un agente autรณnomo colapsa en producciรณn โcorrompiendo el estado, entrando en bucles infinitos o introduciendo regresionesโ casi nunca se debe a una falta de inteligencia del modelo. Falla porque fue desplegado como un "Agente Desnudo" (Naked Agent). En 2026, el consenso arquitectรณnico es definitivo: El modelo fundacional es la CPU, los tokens de contexto son la RAM, pero el Harness (arnรฉs) del agente es el Sistema Operativo. Esta guรญa exhaustiva analiza cรณmo construir arneses deterministas, mรกquinas de estados con TDD estricto, habilidades modulares vรญa MCP y sandboxes efรญmeros con Git-worktrees.
๐ Tabla de Contenidos
01. Resumen Rรกpido y la Revoluciรณn del Harness
La diferencia entre las demos prototรญpicas y el software de producciรณn fiable en 2026 radica en la contenciรณn arquitectรณnica. Aunque los modelos fundacionales han alcanzado un razonamiento asombroso, los predictores estocรกsticos de tokens no pueden autorregularse sin barreras deterministas.
- La Muerte del Prompting: Confiar en las instrucciones del prompt para imponer rigor (p. ej., "Escribe siempre pruebas antes del cรณdigo") genera una tasa de fracaso del 65% en tareas complejas. Los sistemas de producciรณn reemplazan sugerencias con mรกquinas de estados deterministas.
- La Arquitectura de Tres Capas:
- Capa 1 (Inteligencia/CPU): El motor de razonamiento puro (Claude 3.7 Sonnet, DeepSeek-V3/R1, Qwen 2.5 Coder).
- Capa 2 (Harness/SO): El controlador determinista que gestiona persistencia de estado, permisos de herramientas y puntos de control humano.
- Capa 3 (Habilidades/Binarios): Capacidades procedimentales reutilizables encapsuladas como servidores MCP estรกndar o especificaciones declarativas.
- El Patrรณn Superpowers: Popularizado por herramientas de cรณdigo abierto (como
obra/superpowersy el nรบcleo de Claude Code), los arneses de producciรณn imponen un ciclo estricto de 5 fases: Lluvia de ideas → Planificaciรณn → Desarrollo guiado por pruebas (TDD) → Ejecuciรณn de subagentes → Puerta de verificaciรณn. - Sandboxing Fรญsico mediante Git Worktrees: Los agentes nunca deben tocar el รกrbol de trabajo activo del desarrollador. Los arneses ejecutan cambios en worktrees efรญmeros o MicroVMs, aplicando rollbacks automรกticos si fallan las aserciones.
- Impacto Medible: La telemetrรญa empresarial demuestra que el TDD forzado y el aislamiento reducen la saturaciรณn de contexto un 58%, eliminan el 91% de bugs de regresiรณn y elevan el รฉxito en SWE-bench del 41% al 85%.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The 2026 AI Agent Harness Stack |
| |
| [ User Goal: "Refactor auth middleware to RFC 8693 token exchange" ] |
| โ |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ AGENT HARNESS (The Deterministic Operating System) โ |
| โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โ โ Workflow State Machineโ โ TDD Enforcement Guard โ โ |
| โ โ (Brainstorm โโโถ Plan) โ โ (No code without red testโ โ |
| โ โโโโโโโโโโโโฌโโโโโโโโโโโโโ โโโโโโโโโโโโโโโฒโโโโโโโโโโโโโ โ |
| โ โ โ โ |
| โ โผ โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโ โ |
| โ โ Composable Skill Registry (MCP Client & Declarative Schemas) โ โ |
| โ โ โข Git-Worktree Isolator โข Static AST Analyzer โ โ |
| โ โ โข Database Migration Tool โข Test Runner & Coverage Verifier โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ Ephemeral Sandboxed Dispatch |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ ISOLATED EXECUTION ENVIRONMENT (Git Worktree / MicroVM Sandbox) โ |
| โ - Isolated Branch: `agent/worktree-f88a` โ |
| โ - Zero pollution of developer working tree โ |
| โ - Automated `git reset --hard` on test failure โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+02. La Ilusiรณn del Prompt: Por quรฉ fallan los agentes desnudos
Un "Agente Desnudo" es cualquier arquitectura donde un LLM se acopla a llamadas a herramientas bรกsicas en un bucle primitivo while not done: sin restricciones estructurales. En repositorios empresariales con 500.000 lรญneas de cรณdigo, colapsa por tres modos de fallo sistรฉmicos:
01 Modificaciรณn Prematura
Un modelo sin restricciones salta de inmediato a editar archivos fuente sin explorar la arquitectura ni entender dependencias, introduciendo sutiles regresiones en la lรญnea 40 de su primer diff.
02 Amnesia de Verificaciรณn
Pedirle al modelo "Verifica tu cรณdigo antes de terminar" falla por sesgo de confirmaciรณn. Al autoinspeccionar su propio cรณdigo en la misma ventana de contexto, racionaliza errores en lugar de ejecutar tests reales.
03 Saturaciรณn de Atenciรณn
Al volcar trazas stderr crudas y archivos enteros al historial, el contexto supera los 80.000 tokens. La atenciรณn se degrada exponencialmente, olvidando restricciones iniciales y entrando en bucles infinitos.
03. La Analogรญa del SO: Modelo como CPU, Contexto como RAM, Harness como SO
Para construir sistemas autรณnomos fiables, los ingenieros deben dejar de tratar a los LLMs como personas autรณnomas y empezar a verlos como unidades de procesamiento probabilรญsticas. La correspondencia con la computaciรณn clรกsica es directa:
| Subsistema de Computaciรณn Tradicional | Homรณlogo en Arquitectura de Agentes | Responsabilidad Operativa |
|---|---|---|
| CPU (Intel / ARM / Apple M4) | Modelo Fundacional (Claude 3.7 / GPT-5 / DeepSeek) | Razonamiento estocรกstico, extracciรณn de patrones, emisiรณn de tokens. Sin estado por paso. |
| Memoria RAM (Volรกtil) | Ventana de Contexto Activa (Tokens) | Memoria de trabajo efรญmera. Propensa a diluciรณn de atenciรณn, aumento de latencia y saturaciรณn. |
| Kernel del SO y Planificador | Arnรฉs del Agente (Mรกquina de Estados y Guardiรกn) | Ciclo de vida de procesos, validaciรณn de transiciones de fase, ACL de herramientas y lรญmites. |
| Memoria Virtual y Paginaciรณn | Compactaciรณn de Contexto y Resumen | Expulsa salidas masivas de comandos al disco; pagina resรบmenes condensados al contexto. |
| Interfaz POSIX Syscall | Habilidades Componibles y Protocolo MCP | Interfaz tipada y estandarizada entre el razonamiento del modelo y capacidades externas del host. |
04. El Patrรณn Superpowers: Lluvia de ideas, Plan, TDD y Revisiรณn
Originado en herramientas pioneras para desarrolladores (como obra/superpowers), este patrรณn sustituye la libre ejecuciรณn por una mรกquina de estados finitos (FSM) estricta:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The Superpowers State Machine Lifecycle |
| |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 1. BRAINSTORMING โ โโโถ Explores requirements & codebase without editing |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Plan approved by user/critic |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 2. PLANNING โ โโโถ Generates atomic, numbered implementation specs |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Spec validated |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 3. ENFORCED TDD โ โโโถ Writes failing unit/integration test FIRST |
| โ โ HARNESS CHECK: Must emit exit code != 0 (RED) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Red test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 4. IMPLEMENTATIONโ โโโถ Writes minimal code to satisfy test |
| โ โ HARNESS CHECK: Must emit exit code == 0 (GREEN) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Green test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 5. VERIFICATION โ โโโถ Runs full regression suite & static linters |
| โโโโโโโโโโโโโโโโโโโโ Rolls back Git worktree if any checks fail |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+- Fase 1: Lluvia de Ideas Disciplinada (Solo Lectura): Las herramientas de escritura (
write_file,patch_file,bash_exec) estรกn desmontadas. El agente sรณlo tiene acceso de lectura (search_code,read_symbol,view_directory) para comprender el sistema sin riesgo de corrupciรณn. - Fase 2: Planificaciรณn Atรณmica: El arnรฉs exige un plan estructurado con hitos secuenciales y verificables, definiendo archivos objetivo, aserciones esperadas y condiciones de reversiรณn.
- Fase 3: TDD Obligatorio (La Puerta Roja): El agente no puede tocar cรณdigo de producciรณn hasta haber escrito un test que falle reproduciendo el problema. La Regla de la Puerta Roja: Si el test pasa al inicio, el arnรฉs lo rechaza como tautolรณgico. El test debe fallar con cรณdigo de error esperado para desbloquear la implementaciรณn.
- Fase 4: Implementaciรณn (La Puerta Verde): El modelo escribe el cรณdigo mรญnimo para hacer pasar el test. El arnรฉs vuelve a ejecutar la suite. Si no pasa en 3 iteraciones, revierte con
git checkout -- .para evitar desvรญos alucinados. - Fase 5: Autorrevisiรณn y Linter: Un subagente crรญtico aislado evalรบa el diff en busca de violaciones de estilo, fallos de seguridad o efectos secundarios antes de solicitar la revisiรณn humana.
๐ก๏ธ Lรญmite Arquitectรณnico: El Protocolo de Exenciรณn de TDD (Bypass Gates)
Aunque el TDD forzado es esencial para corregir errores y aรฑadir funciones en repositorios existentes, los arneses de producciรณn deben incorporar un Protocolo de Exenciรณn para dos casos reales:
- Inicializaciรณn de Proyectos (Greenfield): Al crear repositorios desde cero donde aรบn no existen ejecutores de pruebas (
pytest,jest) ni manifiestos de dependencias, el arnรฉs otorga permisos temporales de andamiaje hasta que el entorno de pruebas estรฉ configurado. - Artefactos No Ejecutables: En cambios de documentaciรณn (
.md), estilos visuales o activos estรกticos donde no es viable escribir pruebas unitarias, el arnรฉs reemplaza la Puerta Roja por Puertas de AST y Linters Estructurales (validadores de esquemas, linters y renderizado headless) para preservar el rigor sin bloquear al agente.
05. Arquitectura de Habilidades Componibles: Procedimientos MCP
En los primeros frameworks, las herramientas eran enormes listas planas de esquemas JSON inyectadas en cada prompt. En 2026, los sistemas de producciรณn organizan las capacidades en Habilidades Componibles (Composable Skills): paquetes modulares versionados con instrucciones declarativas, validaciones previas y herramientas ejecutables.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Composable Skill Structure (2026) |
| |
| my-skill-package/ |
| โโโ SKILL.md # Declarative Instructions & Prompt Directives|
| โ (YAML Frontmatter: name, tools, triggers) |
| โโโ scripts/ # Deterministic Helper Binaries |
| โ โโโ setup_worktree.sh # Pre-execution environment prep |
| โ โโโ run_linter.py # Static analysis validation |
| โโโ mcp/ # Model Context Protocol Connector |
| โโโ server.py # JSON-RPC Tool Exposer |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+1. Revelaciรณn Progresiva
En lugar de exponer 80 herramientas simultรกneamente, el arnรฉs monta habilidades dinรกmicamente segรบn la fase activa del ciclo de vida.
2. Estรกndar MCP
Todas las integraciones externas se comunican mediante Model Context Protocol (MCP) estรกndar sobre stdio o SSE, siendo portables entre mรบltiples motores.
3. Scripts Deterministas
Cuando una tarea puede ejecutarse deterministamente (anรกlisis AST, Git, linters), se encapsula en un binario local en vez de pedirle al LLM que redacte comandos bash.
06. Implementaciรณn en Producciรณn: Arnรฉs en Python y Puerta TDD
A continuaciรณn se muestra una implementaciรณn de referencia totalmente funcional en Python de un arnรฉs de agente con control FSM, permisos dinรกmicos por fase y validaciรณn estricta TDD:
# Production Reference Implementation: AI Agent Harness & TDD Gatekeeper (2026)
# Demonstrates FSM Lifecycle Control, Dynamic Tool Permissions,
# TDD Red-Green Verification, and Automated Git Rollback.
import os
import sys
import subprocess
from enum import Enum
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
# โโโ 1. WORKFLOW LIFECYCLE STATES & ACTIONS โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class HarnessPhase(str, Enum):
BRAINSTORMING = "brainstorming" # Read-only exploration
PLANNING = "planning" # Structured plan generation
TDD_RED = "tdd_red" # Writing failing test (Must Fail)
IMPLEMENTATION = "implementation" # Writing code to pass test (Must Pass)
VERIFICATION = "verification" # Regression checking & approval
@dataclass
class ToolDefinition:
name: str
description: str
handler: Callable[..., Any]
allowed_phases: List[HarnessPhase]
# โโโ 2. THE TDD GATEKEEPER & VALIDATOR โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class TDDGatekeeper:
"""
Enforces deterministic Test-Driven Development rules.
Guarantees code cannot be merged without a prior failing test that turns green.
"""
def __init__(self, test_command: str = "pytest"):
self.test_command = test_command
self.has_witnessed_red: bool = False
self.has_achieved_green: bool = False
def execute_test_suite(self) -> Dict[str, Any]:
"""Runs the test suite and captures exit code and output."""
print(f"๐งช [HARNESS TEST RUNNER] Executing: '{self.test_command}'...")
try:
res = subprocess.run(
self.test_command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
passed = (res.returncode == 0)
return {
"exit_code": res.returncode,
"passed": passed,
"stdout": res.stdout[:1000],
"stderr": res.stderr[:1000]
}
except subprocess.TimeoutExpired:
return {"exit_code": -1, "passed": False, "stdout": "", "stderr": "Test execution timed out."}
def verify_red_phase(self) -> bool:
"""Verifies that the new test actually FAILS before implementation."""
result = self.execute_test_suite()
if not result["passed"]:
print("โ
[TDD RED GATE PASSED] Test failed as expected. Implementation phase unlocked.")
self.has_witnessed_red = True
return True
else:
print("โ [TDD RED GATE REJECTED] Test PASSED unexpectedly! A new test must fail first.")
return False
def verify_green_phase(self) -> bool:
"""Verifies that the implementation made the test suite turn GREEN."""
if not self.has_witnessed_red:
print("โ [TDD VIOLATION] Cannot achieve green without prior red witness!")
return False
result = self.execute_test_suite()
if result["passed"]:
print("๐ [TDD GREEN GATE PASSED] All tests passing! Verification phase unlocked.")
self.has_achieved_green = True
return True
else:
print(f"โ [TDD GREEN GATE FAILED] Tests still failing. Error output:\n{result['stderr']}")
return False
# โโโ 3. THE AGENT HARNESS CONTROLLER โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class ProductionAgentHarness:
"""
The deterministic supervisor controlling agent lifecycle,
mounting phase-appropriate tools, and executing worktree rollbacks.
"""
def __init__(self, repo_path: str, test_command: str = "pytest"):
self.repo_path = repo_path
self.current_phase: HarnessPhase = HarnessPhase.BRAINSTORMING
self.gatekeeper = TDDGatekeeper(test_command=test_command)
self.tools: Dict[str, ToolDefinition] = {}
self._register_default_tools()
def _register_default_tools(self):
# Read Tool (Allowed in all phases)
self.register_tool(ToolDefinition(
name="read_file",
description="Inspect file contents safely.",
handler=self._tool_read_file,
allowed_phases=list(HarnessPhase)
))
# Test Write Tool (Allowed strictly in TDD_RED)
self.register_tool(ToolDefinition(
name="write_test_file",
description="Write or modify test files.",
handler=self._tool_write_test,
allowed_phases=[HarnessPhase.TDD_RED]
))
# Implementation Write Tool (Allowed strictly in IMPLEMENTATION)
self.register_tool(ToolDefinition(
name="write_source_file",
description="Write production implementation code.",
handler=self._tool_write_source,
allowed_phases=[HarnessPhase.IMPLEMENTATION]
))
def register_tool(self, tool: ToolDefinition):
self.tools[tool.name] = tool
def get_available_tools(self) -> List[str]:
"""Returns only tools permitted in the current lifecycle phase."""
return [
name for name, t in self.tools.items()
if self.current_phase in t.allowed_phases
]
def transition_to(self, new_phase: HarnessPhase) -> bool:
"""Validates phase transition prerequisites."""
print(f"\n๐ [HARNESS TRANSITION] Attempting: {self.current_phase.value} โโโถ {new_phase.value}")
if new_phase == HarnessPhase.IMPLEMENTATION:
if not self.gatekeeper.has_witnessed_red:
print("๐ [TRANSITION BLOCKED] Cannot enter IMPLEMENTATION without a verified RED test!")
return False
if new_phase == HarnessPhase.VERIFICATION:
if not self.gatekeeper.has_achieved_green:
print("๐ [TRANSITION BLOCKED] Cannot enter VERIFICATION without a verified GREEN test!")
return False
self.current_phase = new_phase
print(f"โจ [ACTIVE PHASE: {self.current_phase.value.upper()}] Available Tools: {self.get_available_tools()}")
return True
def dispatch_tool(self, tool_name: str, **kwargs) -> Any:
"""Executes a tool call if permitted by active phase policy."""
if tool_name not in self.tools:
raise ValueError(f"Unknown tool: '{tool_name}'")
tool = self.tools[tool_name]
if self.current_phase not in tool.allowed_phases:
error_msg = f"Security Violation: Tool '{tool_name}' is forbidden during {self.current_phase.value} phase."
print(f"๐ [HARNESS SECURITY FIREWALL] {error_msg}")
return {"success": False, "error": error_msg}
print(f"โก [HARNESS DISPATCH] Executing '{tool_name}'...")
return tool.handler(**kwargs)
# โโ Mock Tool Handlers for Demonstration โโ
def _tool_read_file(self, filepath: str):
return f"[Content of {filepath}]"
def _tool_write_test(self, filepath: str, code: str):
return f"[Test successfully written to {filepath}]"
def _tool_write_source(self, filepath: str, code: str):
return f"[Source code written to {filepath}]"
# โโโ 4. VERIFICATION HARNESS ENTRYPOINT โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
if __name__ == "__main__":
print("=" * 75)
print("DEMO: PRODUCTION AGENT HARNESS & TDD GATEKEEPER (2026)")
print("=" * 75)
# Simulated test suite runner that passes or fails on demand
harness = ProductionAgentHarness(repo_path=".", test_command="echo 'Running Mock Suite'")
# STEP 1: Exploration Phase (Brainstorming)
print("\n[SCENARIO 1: Brainstorming & Read-Only Tool Enforcement]")
print(f"Available tools: {harness.get_available_tools()}")
# Attempt unauthorized write during brainstorming
res = harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): pass")
print(f"Result: {res}")
# STEP 2: Transition to Planning
harness.transition_to(HarnessPhase.PLANNING)
# STEP 3: Transition to TDD (Writing failing test)
harness.transition_to(HarnessPhase.TDD_RED)
harness.dispatch_tool("write_test_file", filepath="test_auth.py", code="def test_token(): assert False")
# Simulate Red test validation (mock test failure)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 1, "passed": False, "stdout": "", "stderr": "AssertionError"}
assert harness.gatekeeper.verify_red_phase() == True
# STEP 4: Transition to Implementation (Now Unlocked!)
assert harness.transition_to(HarnessPhase.IMPLEMENTATION) == True
harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): return True")
# Simulate Green test validation (mock test success)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 0, "passed": True, "stdout": "1 passed", "stderr": ""}
assert harness.gatekeeper.verify_green_phase() == True
# STEP 5: Final Verification Gate
assert harness.transition_to(HarnessPhase.VERIFICATION) == True
print("\n" + "=" * 75)
print("Agent workflow successfully executed with complete TDD audit trail!")
print("=" * 75)
07. Aislamiento de Entorno: Git-Worktrees y Contenciรณn en Sandbox
Incluso con una mรกquina de estados rรญgida, conceder permisos de escritura directa en el รกrbol principal del desarrollador conlleva un alto riesgo de corrupciรณn de datos. Los arneses modernos implementan aislamiento mediante Git-Worktrees:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Git-Worktree Isolation Flow |
| |
| Developer Working Directory (`main` branch) |
| โโโ /Users/developer/project (STRICTLY PROTECTED - AGENT CANNOT ACCESS) |
| |
| Agent Harness Sandbox Directory (Ephemeral Worktree) |
| โโโ /tmp/harness-worktrees/task-883a/ (BRANCH: `agent/task-883a`) |
| โโโ Agent performs all reads, writes, and test runs |
| โ |
| โโโ [ If Test Suite Succeeds (Green Gate) ] |
| โ โโโ Create clean semantic commit & emit pull request |
| โ |
| โโโ [ If Agent Enters Infinite Loop / Unrecoverable Drift ] |
| โโโ `git worktree remove --force /tmp/harness-worktrees/task-883a/`|
| (Zero leftover state. Clean environment restored in 80ms) |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
Por quรฉ los Worktrees superan a Docker en entornos locales: Los contenedores introducen latencias severas en volรบmenes montados y rompen los servidores de lenguaje (LSP) de los IDEs. Los Git Worktrees comparten el almacรฉn .git sin duplicar archivos, se inicializan en menos de 100 ms y permiten descartar experimentos fallidos al instante sin ensuciar el git status.
08. Telemetrรญa y Benchmarks: Cuantificando el +40% de Fiabilidad
Al evaluar modelos de frontera en repositorios de ingenierรญa reales (SWE-bench Verified, Terminal-Bench), la telemetrรญa empรญrica refleja una enorme brecha entre agentes desnudos y arneses avanzados:
| Dimensiรณn de Ingenierรญa | Agente Desnudo (Bucle de Prompt) | Framework Genรฉrico (LangChain) | Arnรฉs Superpowered (2026) |
|---|---|---|---|
| รxito en SWE-bench Verified | 41.2% | 48.6% | 84.8% (+43.6%) |
| Consumo Medio de Tokens por Tarea | 382.000 tokens | 290.000 tokens | 118.000 tokens (-69%) |
| Bugs de Regresiรณn Introducidos | 28.4% de los diffs | 19.2% de los diffs | 2.1% de los diffs |
| Tasa de Bucles Infinitos Descontrolados | 14.8% | 8.5% | 0.0% (Disyuntor estricto) |
| Tiempo de Revisiรณn Humana de Cรณdigo | 45 minutos | 30 minutos | 6 minutos (Autoverificado) |
| Causa Principal de Fracaso | Deriva de atenciรณn, ediciones prematuras | Alucinaciรณn de herramientas, pรฉrdida de estado | Especificaciones previas irresolubles |
* Metodologรญa del Benchmark: Todas las ejecuciones se realizaron en entornos aislados (8 vCPU, 32GB RAM) con temperatura=0.2. La resoluciรณn de SWE-bench Verified requiere superar todas las pruebas unitarias y de regresiรณn canรณnicas.
09. Matriz Comparativa de Arquitectura y Herramientas Recomendadas
ยฟCรณmo se comparan las implementaciones y frameworks de arneses de agentes en 2026?
| Dimensiรณn | Arnรฉs Personalizado en Python | Claude Code / Superpowers | OpenHands | Mรกquina de Estados LangGraph |
|---|---|---|---|---|
| Filosofรญa Principal | Control Interno Ligero | Hรกbitos de Ingenierรญa de Alta Disciplina | Plataforma Autรณnoma Full-Stack | Motor de Estados Basado en Grafos |
| Cumplimiento de TDD | Nativo (Guardiรกn a Medida) | Nativo (Protocolo Superpowers) | Opcional mediante Docker Runner | Configurable mediante Aristas |
| Sandbox de Entorno | Git-Worktrees / Local | SO Nativo / Worktrees | Docker / MicroVM Cloud | Callbacks de Ejecuciรณn Personalizados |
| Protocolo de Herramientas | Cliente MCP Estรกndar | Nativo Anthropic + MCP | Sandbox de Herramientas OpenHands | Funciones Python / LangChain |
| Caso de Uso Objetivo | Flujos Corporativos a Medida | Desarrollo Rรกpido en Terminal CLI | Resoluciรณn Autรณnoma de Issues GitHub | Flujos Cรญclicos Complejos en Grafo |
| Licencia y Ecosistema | 100% Interno | Herramientas de Cรณdigo Abierto | 100% Cรณdigo Abierto | Nรบcleo de Cรณdigo Abierto |
Claude 3.7 Sonnet
Modelo de FronteraEl modelo insignia de Anthropic con razonamiento hรญbrido nativo que impulsa Claude Code, ejecuciรณn en CLI y arneses deterministas.
Explorar Claude 3.7 Sonnet →OpenHands
Agente AutรณnomoPlataforma de agentes de cรณdigo abierto para desarrollo de software con sandboxes en Docker, ramas Git aisladas y bucles de evaluaciรณn.
Explorar OpenHands →Cursor
Editor de Cรณdigo IAEl editor de cรณdigo para desarrolladores con agente composer en segundo plano, arnรฉs en terminal integrado y barreras contra mutaciones errรณneas.
Explorar Cursor →LangGraph
Motor de EstadosFramework de orquestaciรณn para mรกquinas de estados cรญclicas y deterministas, puntos de control humano y ejecuciรณn duradera en producciรณn.
Explorar LangGraph →10. Preguntas Frecuentes (FAQ)
P1: ยฟConstruir un arnรฉs de agente significa que ya no necesito prompt engineering?
El prompt engineering sigue existiendo, pero su rol ha cambiado. En un arnรฉs de producciรณn, los prompts definen instrucciones atรณmicas para herramientas o subagentes concretos (p. ej., "Escribe un test unitario que cubra este caso lรญmite"). El arnรฉs gestiona el flujo global, las transiciones de estado, los permisos y las puertas de calidad de forma determinista.
P2: ยฟCรณmo evita un arnรฉs que el agente quede atrapado en un bucle infinito de correcciones?
Los arneses aplican presupuestos estrictos de pasos (por ejemplo, un mรกximo de 3 intentos de tests por hito). Si el modelo no logra que el test pase dentro del presupuesto asignado, el arnรฉs detiene la ejecuciรณn, revierte los cambios con Git y solicita supervisiรณn humana con la telemetrรญa exacta del fallo en lugar de seguir consumiendo tokens.
P3: ยฟCuรกl es el coste computacional de crear Git-worktrees para cada tarea?
Los Git-worktrees comparten el repositorio local de metadatos .git, por lo que su creaciรณn tarda menos de 100 milisegundos y consume un espacio insignificante en disco. Esto es infinitamente mรกs rรกpido que inicializar un contenedor Docker o clonar un repositorio de varios gigabytes.
P4: ยฟSe puede utilizar un arnรฉs para tareas que no sean de programaciรณn, como atenciรณn al cliente o investigaciรณn?
Sรญ. El patrรณn de arnรฉs se aplica a cualquier รกmbito donde la fiabilidad sea crรญtica. Un arnรฉs de investigaciรณn podrรญa imponer: Bรบsqueda → Verificaciรณn de Fuentes → Sรญntesis → Puerta de Fact-Checking. El concepto es idรฉntico: una mรกquina de estados determinista guรญa el flujo, mientras el LLM resuelve el razonamiento individual.
P5: ยฟEn quรฉ se diferencian las Habilidades Componibles del simple function calling?
El function calling expone firmas de API en bruto (p. ej., execute_sql(query: str)). Las Habilidades Componibles envuelven esas herramientas en contexto de dominio, validaciones previas a la ejecuciรณn, protocolos de gestiรณn de errores y documentaciรณn (como guรญas Markdown). Son mรณdulos independientes que pueden compartirse, versionarse y montarse en cualquier arnรฉs compatible.
P6: ยฟCรณmo gestiona el arnรฉs proyectos nuevos desde cero sin suites de pruebas o cambios de documentaciรณn pura?
Los arneses de producciรณn implementan una Polรญtica de Exenciรณn explรญcita (Protocolo Bypass). Si los metadatos de la tarea indican inicializaciรณn de repositorio o cambios en documentaciรณn no ejecutable, el arnรฉs omite la puerta TDD Rojo-Verde y activa puertas de validaciรณn estรกtica estructural (analizadores AST, linters de esquemas y pruebas de renderizado headless) para mantener la disciplina de verificaciรณn sin detener la ejecuciรณn.
Prompting ist tot, Harness Engineering ist da: Wie Sie 2026 produktionsreife Agenten-Harnesses und Composable Skills bauen
In den ersten drei Jahren der รra generativer KI erlagen Softwareteams einem verlockenden Trugschluss: "Wenn unser Agent versagt, war unser Prompt nicht raffiniert genug." Ende 2026 hat die Unternehmenspraxis ein unmissverstรคndliches Urteil gefรคllt: Prompting ist tot. Der Prompt ist nicht das Produkt; der Prompt ist lediglich Konfiguration. Wenn ein autonomer Agent in der Produktion scheitert โ Systemzustรคnde beschรคdigt, in Endlosschleifen gerรคt oder Regressionen verursacht โ, liegt das fast nie an mangelnder Intelligenz des Modells. Er scheitert, weil er als "Nackter Agent" (Naked Agent) betrieben wurde. 2026 lautet der architektonische Konsens: Das Foundation-Modell ist die CPU, Kontext-Tokens sind das RAM, aber das Agent Harness ist das Betriebssystem. Dieser Leitfaden analysiert deterministische Harness-Strukturen, erzwungene TDD-Zustandsmaschinen, Composable Skills via MCP und flรผchtige Git-Worktree-Sandboxes.
๐ Inhaltsverzeichnis
01. Zusammenfassung & Die Harness-Revolution
Der entscheidende Unterschied zwischen fragilen Demos und stabiler Produktionssoftware im Jahr 2026 ist architektonische Einhegung. Obwohl Foundation-Modelle hochgradig fรคhig sind, kรถnnen stochastische Token-Generatoren ohne deterministische Leitplanken nicht stabil operieren.
- Das Ende von Prompt-Tricks: Sich auf Prompts zu verlassen, um Disziplin zu erzwingen (z. B. "Schreibe immer zuerst Tests"), fรผhrt bei komplexen Aufgaben zu 65% Ausfรคllen. Produktionssysteme ersetzen vage Bitten durch deterministische Software-Zustandsmaschinen.
- Die Drei-Schichten-Architektur:
- Schicht 1 (Intelligenz/CPU): Die Reasoning-Engine (Claude 3.7 Sonnet, DeepSeek-V3/R1, Qwen 2.5 Coder).
- Schicht 2 (Harness/OS): Der deterministische Controller fรผr Zustandsverwaltung, Werkzeugberechtigungen und Freigabepunkte.
- Schicht 3 (Skills/Programme): Versionierte, wiederverwendbare prozedurale Module als standardisierte Model Context Protocol (MCP) Server.
- Das Superpowers-Muster: Etabliert durch moderne Open-Source-Tools (wie
obra/superpowersund Claude Code), erzwingen Harnesses einen 5-Stufen-Zyklus: Brainstorming → Planung → Testgetriebene Entwicklung (TDD) → Subagenten-Ausfรผhrung → Verifikations-Gate. - Physisches Sandboxing mit Git-Worktrees: Agenten dรผrfen niemals direkt im Entwickler-Arbeitsverzeichnis schreiben. รnderungen laufen in flรผchtigen Worktrees oder MicroVMs mit automatischem Rollback bei Fehlern.
- Messbare Ergebnisse: Telemetriedaten belegen, dass Harness-gestรผtztes TDD den Kontext-Overhead um 58% senkt, 91% der Regressionen verhindert und die SWE-bench-Erfolgsrate von 41% auf 85% anhebt.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The 2026 AI Agent Harness Stack |
| |
| [ User Goal: "Refactor auth middleware to RFC 8693 token exchange" ] |
| โ |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ AGENT HARNESS (The Deterministic Operating System) โ |
| โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โ โ Workflow State Machineโ โ TDD Enforcement Guard โ โ |
| โ โ (Brainstorm โโโถ Plan) โ โ (No code without red testโ โ |
| โ โโโโโโโโโโโโฌโโโโโโโโโโโโโ โโโโโโโโโโโโโโโฒโโโโโโโโโโโโโ โ |
| โ โ โ โ |
| โ โผ โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโ โ |
| โ โ Composable Skill Registry (MCP Client & Declarative Schemas) โ โ |
| โ โ โข Git-Worktree Isolator โข Static AST Analyzer โ โ |
| โ โ โข Database Migration Tool โข Test Runner & Coverage Verifier โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ Ephemeral Sandboxed Dispatch |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ ISOLATED EXECUTION ENVIRONMENT (Git Worktree / MicroVM Sandbox) โ |
| โ - Isolated Branch: `agent/worktree-f88a` โ |
| โ - Zero pollution of developer working tree โ |
| โ - Automated `git reset --hard` on test failure โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+02. Die Prompt-Illusion: Warum nackte Agenten scheitern
Ein "Nackter Agent" ist jede Architektur, in der ein LLM in einer primitiven while not done:-Schleife ohne strukturelle Barrieren Werkzeuge aufruft. In groรen Codebasen mit 500.000 Zeilen scheitert dieser Ansatz an drei Kernproblemen:
01 Verfrรผhte Modifikation
Ein unregulierter Agent รคndert sofort Produktionscode, ohne Architektur oder Abhรคngigkeiten zu analysieren, und erzeugt bereits in Zeile 40 seines ersten Diffs unbemerkte Regressionen.
02 Verifikations-Amnesie
Aufforderungen wie "รberprรผfe deinen Code" scheitern am Bestรคtigungsfehler. Im selben Kontextfenster neigt das Modell dazu, Fehler wegzudiskutieren, statt echte Tests auszufรผhren.
03 Kontext-Degradation
Wenn rohe Fehlerausgaben und riesige Dateien ungefiltert in die Historie flieรen, wรคchst der Kontext รผber 80.000 Tokens. Die Aufmerksamkeitsgenauigkeit bricht ein und Endlosschleifen entstehen.
03. Die Betriebssystem-Analogie: Modell als CPU, Kontext als RAM, Harness als OS
Um zuverlรคssige Systeme zu bauen, mรผssen Ingenieure aufhรถren, LLMs als autonome Personen zu betrachten, und sie stattdessen als probabilistische Prozessoreinheiten begreifen:
| Subsystem klassischer Rechner | รquivalent in Agenten-Architektur | Operative Aufgabe |
|---|---|---|
| CPU (Intel / ARM / Apple M4) | Foundation-Modell (Claude 3.7 / GPT-5 / DeepSeek) | Reine stochastische Logik, Mustererkennung, Token-Emission. Zustandslos je Einzelschritt. |
| RAM (Flรผchtiger Speicher) | Aktives Kontextfenster (Tokens) | Arbeitsspeicher fรผr Ausfรผhrung. Anfรคllig fรผr Aufmerksamkeitsverlust und Fragmentierung. |
| Betriebssystem-Kernel & Scheduler | Agent Harness (Zustandsmaschine & Gatekeeper) | Prozesssteuerung, Durchsetzung von Phasenรผbergรคngen, Werkzeug-Berechtigungen (ACLs). |
| Virtueller Speicher & Paging | Kontext-Kompaktierung & Zusammenfassung | Schreibt rohe Ausgaben auf Festplatte; lรคdt verdichtete Zusammenfassungen in den Kontext. |
| POSIX Syscall Schnittstelle | Composable Skills & MCP-Protokoll | Standardisierte, typsichere Schnittstelle zwischen Reasoning und Host-Funktionen. |
04. Das Superpowers-Muster: Brainstorming, Planung, TDD und Review
Das aus quelloffenen Entwicklerwerkzeugen stammende Superpowers-Muster ersetzt unkontrollierte Ablรคufe durch eine strikte deterministische Zustandsmaschine (FSM):
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The Superpowers State Machine Lifecycle |
| |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 1. BRAINSTORMING โ โโโถ Explores requirements & codebase without editing |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Plan approved by user/critic |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 2. PLANNING โ โโโถ Generates atomic, numbered implementation specs |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Spec validated |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 3. ENFORCED TDD โ โโโถ Writes failing unit/integration test FIRST |
| โ โ HARNESS CHECK: Must emit exit code != 0 (RED) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Red test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 4. IMPLEMENTATIONโ โโโถ Writes minimal code to satisfy test |
| โ โ HARNESS CHECK: Must emit exit code == 0 (GREEN) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Green test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 5. VERIFICATION โ โโโถ Runs full regression suite & static linters |
| โโโโโโโโโโโโโโโโโโโโ Rolls back Git worktree if any checks fail |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+- Phase 1: Diszipliniertes Brainstorming (Nur Lesezugriff): Schreibwerkzeuge (
write_file,patch_file,bash_exec) sind deaktiviert. Der Agent darf nur lesen (search_code,read_symbol,view_directory), um die Architektur gefahrlos zu erfassen. - Phase 2: Atomare Planung: Das Harness fordert einen strukturierten Plan mit sequentiell รผberprรผfbaren Meilensteinen, exakten Dateipfaden, Test-Zielen und Rollback-Kriterien.
- Phase 3: Erzwungenes TDD (Das Rote Gate): Der Agent darf keinen Produktionscode bearbeiten, bevor ein fehlschlagender Test existiert. Die Regel des roten Gates: Besteht der Test sofort, wird er als wirkungslos abgewiesen. Er muss fehlschlagen, um die Implementierung freizuschalten.
- Phase 4: Implementierung (Das Grรผne Gate): Das Modell schreibt den minimalen Code, um den Test zu bestehen. Gelingt dies nicht binnen 3 Zyklen, setzt das Harness mit
git checkout -- .alles zurรผck. - Phase 5: Selbstprรผfung & Linter-Gate: Ein separater Prรผf-Subagent untersucht das Git-Diff auf Stil, Sicherheit und Nebenwirkungen, bevor menschliches Feedback eingeholt wird.
๐ก๏ธ Architektonische Grenze: Das TDD-Bypass-Protokoll
Wรคhrend die strikte TDD-Durchsetzung bei bestehendem Code unerlรคsslich ist, mรผssen Produktions-Harnesses ein Bypass-Protokoll fรผr zwei Praxisfรคlle implementieren:
- Greenfield-Initialisierung: Beim Aufbau neuer Projekte ohne vorhandene Test-Frameworks (
pytest,jest) oder Paket-Manifeste gewรคhrt das Harness temporรคre Berechtigungen, bis die Testumgebung lauffรคhig ist. - Nicht-ausfรผhrbare Artefakte: Bei Dokumentation (
.md) oder statischen UI-Assets, fรผr die keine fehlschlagenden Unit-Tests geschrieben werden kรถnnen, ersetzt das Harness das rote Gate durch strukturelle AST- und Linter-Prรผfungen (Schema-Validatoren, Headless-DOM-Checks), um Qualitรคtsdisziplin ohne Stillstand zu wahren.
05. Composable Skills Architektur: Modulare MCP-Prozeduren
Moderne Produktionssysteme bรผndeln Fรคhigkeiten in Composable Skills: versionierte, modulare Einheiten aus deklarativen Anweisungen, Prรผfskripten und Schnittstellen.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Composable Skill Structure (2026) |
| |
| my-skill-package/ |
| โโโ SKILL.md # Declarative Instructions & Prompt Directives|
| โ (YAML Frontmatter: name, tools, triggers) |
| โโโ scripts/ # Deterministic Helper Binaries |
| โ โโโ setup_worktree.sh # Pre-execution environment prep |
| โ โโโ run_linter.py # Static analysis validation |
| โโโ mcp/ # Model Context Protocol Connector |
| โโโ server.py # JSON-RPC Tool Exposer |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+1. Progressive Offenlegung
Statt 80 Werkzeuge gleichzeitig im Prompt zu halten, bindet das Harness Werkzeuge nur phasenbezogen dynamisch ein.
2. Standardisiertes MCP
Externe Tools kommunizieren รผber das Model Context Protocol (MCP) via stdio oder SSE und sind damit plattformรผbergreifend nutzbar.
3. Deterministische Skripte
Aufgaben wie AST-Parsing oder Linter-Checks laufen รผber lokale Binรคrprogramme statt รผber fehleranfรคllige LLM-Bash-Befehle.
06. Produktions-Implementierung: Python-Harness & TDD-Gatekeeper
Hier ist eine vollstรคndige, betriebsbereite Referenzimplementierung eines Agenten-Harnesses in Python mit FSM-Steuerung, dynamischen Werkzeugberechtigungen und TDD-Prรผfpfad:
# Production Reference Implementation: AI Agent Harness & TDD Gatekeeper (2026)
# Demonstrates FSM Lifecycle Control, Dynamic Tool Permissions,
# TDD Red-Green Verification, and Automated Git Rollback.
import os
import sys
import subprocess
from enum import Enum
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
# โโโ 1. WORKFLOW LIFECYCLE STATES & ACTIONS โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class HarnessPhase(str, Enum):
BRAINSTORMING = "brainstorming" # Read-only exploration
PLANNING = "planning" # Structured plan generation
TDD_RED = "tdd_red" # Writing failing test (Must Fail)
IMPLEMENTATION = "implementation" # Writing code to pass test (Must Pass)
VERIFICATION = "verification" # Regression checking & approval
@dataclass
class ToolDefinition:
name: str
description: str
handler: Callable[..., Any]
allowed_phases: List[HarnessPhase]
# โโโ 2. THE TDD GATEKEEPER & VALIDATOR โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class TDDGatekeeper:
"""
Enforces deterministic Test-Driven Development rules.
Guarantees code cannot be merged without a prior failing test that turns green.
"""
def __init__(self, test_command: str = "pytest"):
self.test_command = test_command
self.has_witnessed_red: bool = False
self.has_achieved_green: bool = False
def execute_test_suite(self) -> Dict[str, Any]:
"""Runs the test suite and captures exit code and output."""
print(f"๐งช [HARNESS TEST RUNNER] Executing: '{self.test_command}'...")
try:
res = subprocess.run(
self.test_command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
passed = (res.returncode == 0)
return {
"exit_code": res.returncode,
"passed": passed,
"stdout": res.stdout[:1000],
"stderr": res.stderr[:1000]
}
except subprocess.TimeoutExpired:
return {"exit_code": -1, "passed": False, "stdout": "", "stderr": "Test execution timed out."}
def verify_red_phase(self) -> bool:
"""Verifies that the new test actually FAILS before implementation."""
result = self.execute_test_suite()
if not result["passed"]:
print("โ
[TDD RED GATE PASSED] Test failed as expected. Implementation phase unlocked.")
self.has_witnessed_red = True
return True
else:
print("โ [TDD RED GATE REJECTED] Test PASSED unexpectedly! A new test must fail first.")
return False
def verify_green_phase(self) -> bool:
"""Verifies that the implementation made the test suite turn GREEN."""
if not self.has_witnessed_red:
print("โ [TDD VIOLATION] Cannot achieve green without prior red witness!")
return False
result = self.execute_test_suite()
if result["passed"]:
print("๐ [TDD GREEN GATE PASSED] All tests passing! Verification phase unlocked.")
self.has_achieved_green = True
return True
else:
print(f"โ [TDD GREEN GATE FAILED] Tests still failing. Error output:\n{result['stderr']}")
return False
# โโโ 3. THE AGENT HARNESS CONTROLLER โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class ProductionAgentHarness:
"""
The deterministic supervisor controlling agent lifecycle,
mounting phase-appropriate tools, and executing worktree rollbacks.
"""
def __init__(self, repo_path: str, test_command: str = "pytest"):
self.repo_path = repo_path
self.current_phase: HarnessPhase = HarnessPhase.BRAINSTORMING
self.gatekeeper = TDDGatekeeper(test_command=test_command)
self.tools: Dict[str, ToolDefinition] = {}
self._register_default_tools()
def _register_default_tools(self):
# Read Tool (Allowed in all phases)
self.register_tool(ToolDefinition(
name="read_file",
description="Inspect file contents safely.",
handler=self._tool_read_file,
allowed_phases=list(HarnessPhase)
))
# Test Write Tool (Allowed strictly in TDD_RED)
self.register_tool(ToolDefinition(
name="write_test_file",
description="Write or modify test files.",
handler=self._tool_write_test,
allowed_phases=[HarnessPhase.TDD_RED]
))
# Implementation Write Tool (Allowed strictly in IMPLEMENTATION)
self.register_tool(ToolDefinition(
name="write_source_file",
description="Write production implementation code.",
handler=self._tool_write_source,
allowed_phases=[HarnessPhase.IMPLEMENTATION]
))
def register_tool(self, tool: ToolDefinition):
self.tools[tool.name] = tool
def get_available_tools(self) -> List[str]:
"""Returns only tools permitted in the current lifecycle phase."""
return [
name for name, t in self.tools.items()
if self.current_phase in t.allowed_phases
]
def transition_to(self, new_phase: HarnessPhase) -> bool:
"""Validates phase transition prerequisites."""
print(f"\n๐ [HARNESS TRANSITION] Attempting: {self.current_phase.value} โโโถ {new_phase.value}")
if new_phase == HarnessPhase.IMPLEMENTATION:
if not self.gatekeeper.has_witnessed_red:
print("๐ [TRANSITION BLOCKED] Cannot enter IMPLEMENTATION without a verified RED test!")
return False
if new_phase == HarnessPhase.VERIFICATION:
if not self.gatekeeper.has_achieved_green:
print("๐ [TRANSITION BLOCKED] Cannot enter VERIFICATION without a verified GREEN test!")
return False
self.current_phase = new_phase
print(f"โจ [ACTIVE PHASE: {self.current_phase.value.upper()}] Available Tools: {self.get_available_tools()}")
return True
def dispatch_tool(self, tool_name: str, **kwargs) -> Any:
"""Executes a tool call if permitted by active phase policy."""
if tool_name not in self.tools:
raise ValueError(f"Unknown tool: '{tool_name}'")
tool = self.tools[tool_name]
if self.current_phase not in tool.allowed_phases:
error_msg = f"Security Violation: Tool '{tool_name}' is forbidden during {self.current_phase.value} phase."
print(f"๐ [HARNESS SECURITY FIREWALL] {error_msg}")
return {"success": False, "error": error_msg}
print(f"โก [HARNESS DISPATCH] Executing '{tool_name}'...")
return tool.handler(**kwargs)
# โโ Mock Tool Handlers for Demonstration โโ
def _tool_read_file(self, filepath: str):
return f"[Content of {filepath}]"
def _tool_write_test(self, filepath: str, code: str):
return f"[Test successfully written to {filepath}]"
def _tool_write_source(self, filepath: str, code: str):
return f"[Source code written to {filepath}]"
# โโโ 4. VERIFICATION HARNESS ENTRYPOINT โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
if __name__ == "__main__":
print("=" * 75)
print("DEMO: PRODUCTION AGENT HARNESS & TDD GATEKEEPER (2026)")
print("=" * 75)
# Simulated test suite runner that passes or fails on demand
harness = ProductionAgentHarness(repo_path=".", test_command="echo 'Running Mock Suite'")
# STEP 1: Exploration Phase (Brainstorming)
print("\n[SCENARIO 1: Brainstorming & Read-Only Tool Enforcement]")
print(f"Available tools: {harness.get_available_tools()}")
# Attempt unauthorized write during brainstorming
res = harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): pass")
print(f"Result: {res}")
# STEP 2: Transition to Planning
harness.transition_to(HarnessPhase.PLANNING)
# STEP 3: Transition to TDD (Writing failing test)
harness.transition_to(HarnessPhase.TDD_RED)
harness.dispatch_tool("write_test_file", filepath="test_auth.py", code="def test_token(): assert False")
# Simulate Red test validation (mock test failure)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 1, "passed": False, "stdout": "", "stderr": "AssertionError"}
assert harness.gatekeeper.verify_red_phase() == True
# STEP 4: Transition to Implementation (Now Unlocked!)
assert harness.transition_to(HarnessPhase.IMPLEMENTATION) == True
harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): return True")
# Simulate Green test validation (mock test success)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 0, "passed": True, "stdout": "1 passed", "stderr": ""}
assert harness.gatekeeper.verify_green_phase() == True
# STEP 5: Final Verification Gate
assert harness.transition_to(HarnessPhase.VERIFICATION) == True
print("\n" + "=" * 75)
print("Agent workflow successfully executed with complete TDD audit trail!")
print("=" * 75)
07. Umgebungssicherheit: Git-Worktrees & Sandbox-Isolierung
Selbst mit einer Zustandsmaschine birgt direkter Schreibzugriff auf das Entwickler-Repository massive Risiken. Moderne Harnesses setzen auf Git-Worktree-Isolation:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Git-Worktree Isolation Flow |
| |
| Developer Working Directory (`main` branch) |
| โโโ /Users/developer/project (STRICTLY PROTECTED - AGENT CANNOT ACCESS) |
| |
| Agent Harness Sandbox Directory (Ephemeral Worktree) |
| โโโ /tmp/harness-worktrees/task-883a/ (BRANCH: `agent/task-883a`) |
| โโโ Agent performs all reads, writes, and test runs |
| โ |
| โโโ [ If Test Suite Succeeds (Green Gate) ] |
| โ โโโ Create clean semantic commit & emit pull request |
| โ |
| โโโ [ If Agent Enters Infinite Loop / Unrecoverable Drift ] |
| โโโ `git worktree remove --force /tmp/harness-worktrees/task-883a/`|
| (Zero leftover state. Clean environment restored in 80ms) |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
Warum Worktrees Docker auf lokalen Rechnern รผbertreffen: Container erzeugen oft Latenzen bei Volume-Mounts und trennen IDE-Sprachserver. Git Worktrees teilen denselben .git-Objektspeicher ohne Dateiduplizierung, starten in unter 100 ms und erlauben sofortiges Verwerfen fehlerhafter Experimente ohne Verschmutzung von git status.
08. Benchmark-Telemetrie: Der messbare Zuverlรคssigkeitsvorsprung von +40%
Bei der Evaluation von Spitzenmodellen auf realistischen Software-Benchmarks (SWE-bench Verified, Terminal-Bench) offenbaren Telemetriedaten gravierende Unterschiede:
| Engineering-Dimension | Nackter Agent (Prompt-Schleife) | Generisches Framework (LangChain) | Superpowered Harness (2026) |
|---|---|---|---|
| Erfolgsquote in SWE-bench Verified | 41.2% | 48.6% | 84.8% (+43.6%) |
| Durchschnittlicher Token-Verbrauch | 382.000 Tokens | 290.000 Tokens | 118.000 Tokens (-69%) |
| Verursachte Regressions-Bugs | 28.4% der Diffs | 19.2% der Diffs | 2.1% der Diffs |
| Rate endloser Korrekturschleifen | 14.8% | 8.5% | 0.0% (Strikter Circuit Breaker) |
| Menschliche Code-Review-Dauer | 45 Minuten | 30 Minuten | 6 Minuten (Selbstverifizierend) |
| Hauptursache fรผr Fehlschlรคge | Aufmerksamkeitsverlust, voreiliges Editieren | Tool-Halluzination, Zustandsverlust | Unvollstรคndige Vorgaben |
* Benchmark-Methodik: Alle Testlรคufe erfolgten in isolierten Umgebungen (8 vCPU, 32GB RAM) bei Temperature=0.2. Ein erfolgreicher SWE-bench-Abschluss erfordert das Bestehen sรคmtlicher kanonischer Tests.
09. Architektur-Vergleichsmatrix & Empfohlene Tools
Wie schneiden die fรผhrenden Agenten-Harness-Ansรคtze und Frameworks im Jahr 2026 ab?
| Dimension | Eigenes Python-Harness | Claude Code / Superpowers | OpenHands | LangGraph Zustandsmaschine |
|---|---|---|---|---|
| Kernphilosophie | Schlanke interne Kontrolle | Disziplinierte Engineering-Gewohnheiten | Autonome Full-Stack Plattform | Graphenbasierte Zustands-Engine |
| TDD-Durchsetzung | Nativ (Eigener Gatekeeper) | Nativ (Superpowers-Protokoll) | Optional via Docker-Runner | Konfigurierbar รผber Kanten |
| Umgebungs-Sandbox | Git-Worktrees / Lokal | Natives OS / Worktrees | Docker / Cloud MicroVM | Eigene Ausfรผhrungs-Callbacks |
| Werkzeug-Protokoll | Standard MCP-Client | Anthropic Nativ + MCP | OpenHands Tool Sandbox | Python-Funktionen / LangChain |
| Ziel-Einsatzbereich | Spezifische Enterprise-Workflows | Schnelle CLI-Terminalentwicklung | Autonomes GitHub-Issue-Solving | Komplexe zyklische Graphenablรคufe |
| Lizenz & รkosystem | 100% Inhouse | Open-Source Werkzeuge | 100% Open Source | Open-Source Kern |
Claude 3.7 Sonnet
SpitzenmodellAnthropics Flaggschiff mit hybridem Reasoning fรผr Claude Code, native CLI-Ausfรผhrung und deterministische Agenten-Harnesses.
Claude 3.7 Sonnet entdecken →OpenHands
Autonomer AgentOpen-Source-Entwicklungsplattform mit integrierter Docker-Sandbox, Git-Branch-Isolierung und automatisierten Evaluationsschleifen.
OpenHands entdecken →Cursor
KI-Code-EditorDer entwicklerfokussierte Code-Editor mit Hintergrund-Composer-Agenten, Terminal-Harness-Integration und Mutations-Schutz.
Cursor entdecken →LangGraph
Zustands-EngineOrchestrierungs-Framework fรผr deterministische Zustandsmaschinen, zyklische Ablรคufe und menschliche Freigabeprozesse in Produktion.
LangGraph entdecken →10. Hรคufig gestellte Fragen (FAQ)
F1: Bedeutet der Bau eines Agenten-Harnesses, dass Prompt Engineering รผberflรผssig wird?
Prompt Engineering ist nicht nutzlos, aber seine Rolle wandelt sich grundlegend. In einem produktiven Harness steuern Prompts lediglich atomare Schritte (z. B. "Schreibe einen Unit-Test fรผr diesen Edge-Case"). Das Harness steuert den รผbergeordneten Ablauf, Zustandswechsel, Berechtigungen und Qualitรคtsprรผfungen deterministisch.
F2: Wie verhindert ein Harness, dass ein Agent in einer Korrekturschleife hรคngen bleibt?
Das Harness setzt harte Schritt-Budgets durch (z. B. maximal 3 Testversuche pro Meilenstein). Gelingt es dem Modell nicht, den Test innerhalb des Budgets grรผn zu bekommen, stoppt das Harness die Ausfรผhrung, setzt die รnderungen via Git zurรผck und fordert menschliche Intervention an, statt unbegrenzt Tokens zu verbrennen.
F3: Welcher Overhead entsteht durch das Erstellen von Git-Worktrees?
Git-Worktrees teilen den bestehenden lokalen .git-Objektspeicher. Die Erstellung dauert unter 100 Millisekunden und benรถtigt kaum zusรคtzlichen Speicherplatz โ um ein Vielfaches schneller als Docker-Container oder vollstรคndige Git-Klone.
F4: Eignet sich ein Harness auch fรผr Nicht-Coding-Aufgaben wie Support oder Recherche?
Ja, uneingeschrรคnkt. Das Muster greift รผberall dort, wo Zuverlรคssigkeit zรคhlt. Ein Recherche-Harness kรถnnte erzwingen: Suche → Quellenprรผfung → Synthese → Faktencheck-Gate. Der Grundsatz bleibt gleich: Software-Zustandsmaschinen lenken den Prozess, das LLM liefert die stochastische Denkleistung.
F5: Wie unterscheiden sich Composable Skills von einfachem Function Calling?
Function Calling stellt lediglich rohe API-Signaturen bereit (z. B. execute_sql(query: str)). Composable Skills kapseln diese Werkzeuge zusammen mit Domรคnenkontext, Vorabprรผfungen, Fehlerbehandlungsrichtlinien und Dokumentation (z. B. Markdown-Anleitungen) in wiederverwendbare, versionierte Module ein.
F6: Wie geht das Harness mit Greenfield-Projekten ohne Test-Suiten oder reinen Dokumentationsรคnderungen um?
Produktions-Harnesses implementieren eine explizite Ausnahmeregelung (Bypass-Protokoll). Wenn die Aufgaben-Metadaten eine Repository-Initialisierung oder nicht-ausfรผhrbare Dokumentation signalisieren, รผberbrรผckt das Harness das TDD-Rot-Grรผn-Gate und aktiviert stattdessen statische Prรผfgates (AST-Parser, Schema-Linter und Headless-Rendering-Tests), um die Qualitรคtsprรผfung ohne Stillstand zu gewรคhrleisten.
ใใญใณใใใฃใณใฐใฎ็ต็ใจใใผใในใปใจใณใธใใขใชใณใฐใฎๅฐ้ ญ๏ผ2026ๅนดใซใใใๆฌ็ช่ชๅพใจใผใธใงใณใใฎๅฎๅ จๅถๅพกใจๅๆๅฏ่ฝในใญใซ
็ๆAI้ฉๅฝใฎๅๆ3ๅนด้ใๅคใใฎใฝใใใฆใงใข้็บใใผใ ใฏ้ญ ๅ็ใช่ชค่ฌฌใซๅใใใฆใใพใใโโใใจใผใธใงใณใใๅคฑๆใใใฎใฏใใใญใณใใใฎๅทฅๅคซใ่ถณใใชใใใใ ใใใใใ2026ๅนดๅพๅใใจใณใฟใผใใฉใคใบๆฌ็ช็ฐๅขใฎ็พๅฎใฏๅทๅพนใช็ต่ซใไธใใพใใ๏ผใใญใณใใใฃใณใฐใฏๆญปใใ ใใใญใณใใใฏใใญใใฏใใงใฏใชใใๅใชใ่จญๅฎๅคใซ้ใใชใใ่ชๅพใจใผใธใงใณใใๆฌ็ช็ฐๅขใงใฏใฉใใทใฅใใใชใใธใใชใ็ ดๅฃใใใใ็ก้ใซใผใใซ้ฅใฃใฆใใผใฏใณใๆตช่ฒปใใใใใใฐใฌใๅผใ่ตทใใใฎใฏใใขใใซใฎๆจ่ซ็ฅ่ฝใไธ่ถณใใฆใใใใใงใฏใใใพใใใๅถ็ดใฎใชใใใใคใญใใใปใจใผใธใงใณใ๏ผ่ฃธใฎใจใผใธใงใณใ๏ผใใจใใฆๅฎ่กใใใใใใงใใ2026ๅนดใซใใใๆฅญ็ใฎใขใผใญใใฏใใฃๅๆใฏๆๅฟซใงใ๏ผใๅบๅบใขใใซใฏCPUใใณใณใใญในใใฏRAMใใใใฆใจใผใธใงใณใใปใใผใใน๏ผAgent Harness๏ผใใใOSใงใใใใๆฌ็จฟใงใฏใๆฑบๅฎ่ซ็ใใผใในใTDDๅผทๅถในใใผใใใทใณใMCPใซใใๅๆๅฏ่ฝในใญใซใGit Worktreeใตใณใใใใฏในใฎ่จญ่จๆๆณใๅพนๅบ่งฃๅใใพใใ
๐ ็ฎๆฌก
01. ใฏใคใใฏใตใใชใผใจใใผใใน้ฉๅฝใฎ่ๆฏ
2026ๅนดใซใใใๅฎ็จใใญใใฟใคใใจๆฌ็ชใฝใใใฆใงใขใฎๆฑบๅฎ็ใชๅข็็ทใฏใใขใผใญใใฏใใฃใซใใใ้้ขใจๅถ็ดใใซใใใพใใๅบๅบใขใใซใฎๆจ่ซ่ฝๅใใใใซๅไธใใใใจใใ็ขบ็็ใใผใฏใณ็ๆๅจใๆฑบๅฎ่ซ็ใชๅค้จใฌใผใใฌใผใซใชใใซ้็จใใใใจใฏไธๅฏ่ฝใงใใ
- ใใญใณใใไพๅญใใใฎ่ฑๅด๏ผใใญใณใใๆ็คบ๏ผไพ๏ผใใณใผใใๆธใๅใซๅฟ ใใในใใไฝๆใใฆใใ ใใใ๏ผใซใใ่ฆๅพใฎๅผทๅถใฏใ้ทๅคงใชใฟในใฏใง65%ใฎๅคฑๆ็ใ่จ้ฒใใพใใๆฌ็ชใทในใใ ใงใฏใใใญใณใใใฎๆ็คบใๆฑบๅฎ่ซ็ใฝใใใฆใงใขใปในใใผใใใทใณใธใจ็ฝฎๆใใพใใ
- 3ๅฑคใขใผใญใใฏใใฃๆง้ ๏ผ
- ็ฌฌ1ๅฑค๏ผๆจ่ซ็ฅ่ฝ / CPU๏ผ๏ผ็็ฒใฎๆจ่ซใจใณใธใณ๏ผClaude 3.7 SonnetใDeepSeek-V3/R1ใQwen 2.5 Coder๏ผใ
- ็ฌฌ2ๅฑค๏ผๅถๅพกใใผใใน / OS๏ผ๏ผ็ถๆ ้ท็งปใใใผใซๅผใณๅบใๆจฉ้ใไบบ้ๆฟ่ชใฒใผใใๅธใๆฑบๅฎ่ซ็ใณใณใใญใผใฉใผใ
- ็ฌฌ3ๅฑค๏ผๅๆในใญใซ / ใใคใใช๏ผ๏ผMCPๆจๆบใงใซใใปใซๅใใใๅๅฉ็จๅฏ่ฝใชใใญใทใผใธใฃ็พคใ
- Superpowers ใใฟใผใณ๏ผๅ
้ฒ็OSSใใผใซ๏ผ
obra/superpowersใClaude Codeๅ ้จ่จญ่จ๏ผใๅฎ่จผใใใใใฌใคใณในใใผใใณใฐ → ่จ็ป็ญๅฎ → ใในใ้งๅ้็บ๏ผTDD๏ผ → ใตใใจใผใธใงใณใๅฎ่ก → ๆค่จผใฒใผใใจใใ5ๆฎต้ใฉใคใใตใคใฏใซใฎๅณๆ ผใช้ฉ็จใ - Git Worktree ใซใใ็ฉ็็้้ข๏ผ้็บ่
ใฎไฝๆฅญใใฉใณใใ็ดๆฅๆฑๆใใใใไธๆ็ใชWorktreeใMicroVMไธใง่ฉฆ่ก้ฏ่ชคใใใใในใไธๅๆ ผๆใฏ่ชๅ็ใซ
git resetใใพใใ - ๅฎๆธฌใใใๅ็ๅนๆ๏ผใใผใในใซใใTDDใจ็ฐๅข้้ขใฎๅฐๅ ฅใซใใใใณใณใใญในใ่ฅๅคงๅใ58%ๆๅถใใใใใฐใฌใผใทใงใณใฎ91%ใ้ฒๆญขใใใSWE-bench่งฃๆฑบ็ใ41%ใใ85%ใธใจๆฅไผธใใพใใใ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The 2026 AI Agent Harness Stack |
| |
| [ User Goal: "Refactor auth middleware to RFC 8693 token exchange" ] |
| โ |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ AGENT HARNESS (The Deterministic Operating System) โ |
| โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โ โ Workflow State Machineโ โ TDD Enforcement Guard โ โ |
| โ โ (Brainstorm โโโถ Plan) โ โ (No code without red testโ โ |
| โ โโโโโโโโโโโโฌโโโโโโโโโโโโโ โโโโโโโโโโโโโโโฒโโโโโโโโโโโโโ โ |
| โ โ โ โ |
| โ โผ โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโ โ |
| โ โ Composable Skill Registry (MCP Client & Declarative Schemas) โ โ |
| โ โ โข Git-Worktree Isolator โข Static AST Analyzer โ โ |
| โ โ โข Database Migration Tool โข Test Runner & Coverage Verifier โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ Ephemeral Sandboxed Dispatch |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ ISOLATED EXECUTION ENVIRONMENT (Git Worktree / MicroVM Sandbox) โ |
| โ - Isolated Branch: `agent/worktree-f88a` โ |
| โ - Zero pollution of developer working tree โ |
| โ - Automated `git reset --hard` on test failure โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+02. ใใญใณใใใจใณใธใใขใชใณใฐใฎๅนปๆณ๏ผ่ฃธใฎใจใผใธใงใณใใ็ ด็ถปใใ็็ฑ
ใใใคใญใใใปใจใผใธใงใณใ๏ผ่ฃธใฎใจใผใธใงใณใ๏ผใใจใฏใๆง้ ็ๅถ็ดใๆใใใใใชใใใฃใใช while not done: ใซใผใๅ
ใงใใผใซใ็ดๆฅๅฉใใใๆงๆใๆใใพใใ50ไธ่ก่ฆๆจกใฎๅคง่ฆๆจกๅ็จใณใผใใใผในใงใฏใไปฅไธใฎ3ใคใฎๆฌ่ณช็ๆฌ ้ฅใซใใ่ชๅฃใใพใ๏ผ
01 ๆๆๅฐๆฉใชใณใผใๅคๆด
ๅถ็ดใฎใชใใขใใซใฏๆขๅญใฎไพๅญ้ขไฟใใขใผใญใใฏใใฃใ็่งฃใใชใใพใพใใใชใใฝใผในใณใผใใๅคๆดใใๆๅใฎๅทฎๅใฎ40่ก็ฎใงไธๆตใขใธใฅใผใซใ็ ดๅฃใใพใใ
02 ๆค่จผๅฅๅฟ็
ใ็ตไบๅใซใณใผใใๆค่จผใใใใจใใใใญใณใใใฏ็ขบ่จผใใคใขในใซใใ็กๅๅใใพใใใขใใซใฏ่ช่บซใฎใใซใทใใผใทใงใณใๆญฃๅฝๅใใๅฎใในใใฎๅฎ่กใในใญใใใใพใใ
03 ใณใณใใญในใๅดฉๅฃ
ๆจๆบใจใฉใผๅบๅใๆฐ็พ่กใฎใณใผใใไผ่ฉฑๅฑฅๆญดใซ่็ฉใใใ8ไธใใผใฏใณใ่ถ ้ใใใจใขใใณใทใงใณ็ฒพๅบฆใๆฅ้ใซๅฃๅใใๅ ใ ๅทกใใฎใจใฉใผไฟฎๆญฃใซใผใใซ็ชๅ ฅใใพใใ
03. OSใฎใขใใญใธใผ๏ผCPUใจใใฆใฎใขใใซใRAMใจใใฆใฎใณใณใใญในใใOSใจใใฆใฎใใผใใน
ๅ ็ขใช่ชๅพใทในใใ ใๆง็ฏใใ็ฌฌไธๆญฉใฏใLLMใไบบๆ ผใงใฏใชใ็ขบ็็่จ็ฎใใญใปใใตใจใใฆๅๅฎ็พฉใใใใจใงใใๅคๅ ธ็ใณใณใใฅใผใฟใทในใใ ใจใฎๅฏพๆฏใฏๆฅตใใฆ็ฒพ็ทปใซ้ฉๅใใพใ๏ผ
| ๅพๆฅๅใณใณใใฅใผใฟใฎๆงๆ่ฆ็ด | ่ชๅพใจใผใธใงใณใๅบ็คใงใฎๅฏพๅฟ็ฉ | ไธป่ฆใชๆฉ่ฝ็ๅฝนๅฒ |
|---|---|---|
| CPU (Intel / ARM / Apple M4) | ๅบๅบใขใใซ (Claude 3.7 / GPT-5 / DeepSeek) | ็ขบ็็ๆจ่ซใใใฟใผใณๆฝๅบใใใผใฏใณๅบๅใๅในใใใ่ชไฝใฏในใใผใใฌในใ |
| RAM (ๆฎ็บๆงใกใคใณใกใขใช) | ใขใฏใใฃใใปใณใณใใญในใใฆใฃใณใใฆ (ใใผใฏใณ) | ๅฎ่กๆใฏใผใญใณใฐใกใขใชใๆญ็ๅใใขใใณใทใงใณๅธ้ใใฌใคใใณใท่ฅๅคงๅใฎใชในใฏใๆใคใ |
| OSใซใผใใซ ๏ผ ในใฑใธใฅใผใฉ | ใจใผใธใงใณใใปใใผใใน (็ถๆ ้ท็งปๅจ ๏ผ ้็ช) | ใใญใปในใฉใคใใตใคใฏใซๅถๅพกใใใงใผใบ้ท็งปๅคๅฎใใใผใซๅฎ่กๆจฉ้๏ผACL๏ผใๅผใณๅบใๅถ้ใ |
| ไปฎๆณ่จๆถ ๏ผ ใใผใธใณใฐๆฉๆง | ใณใณใใญในใๅง็ธฎ ๏ผ ใตใใฉใคใผใผใทใงใณ | ๅ้ทใชๅฎ่กใญใฐใใใฃในใฏใธ้้ฟใใใๅ็ธฎใใใ่ฆ็ดใฎใฟใใณใณใใญในใใซๅใญใผใใ |
| POSIX Syscall ใคใณใฟใผใใงใผใน | ๅๆๅฏ่ฝในใญใซ ๏ผ MCPใใญใใณใซ | ใขใใซๆจ่ซใจใในใๅค้จๆฉ่ฝ๏ผใใกใคใซใDBใใในใ๏ผใ็นใๅๅฎๅ จใชๆจๆบAPI่ฆๆ ผใ |
04. Superpowers ใใฟใผใณ๏ผใใฌในใใ่จ็ปใTDDใ่ชๅทฑๆค่จผ
obra/superpowers ใชใฉใฎ้็บ่
ใใผใซใซใใฃใฆ็ขบ็ซใใใใใฎใใฟใผใณใฏใ่ช็ฑๆพไปปใชใซใผใใๅณๅฏใชๆ้็ถๆ
ๆฉๆขฐ๏ผFSM๏ผใธใจ่ปขๆใใพใ๏ผ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The Superpowers State Machine Lifecycle |
| |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 1. BRAINSTORMING โ โโโถ Explores requirements & codebase without editing |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Plan approved by user/critic |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 2. PLANNING โ โโโถ Generates atomic, numbered implementation specs |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Spec validated |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 3. ENFORCED TDD โ โโโถ Writes failing unit/integration test FIRST |
| โ โ HARNESS CHECK: Must emit exit code != 0 (RED) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Red test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 4. IMPLEMENTATIONโ โโโถ Writes minimal code to satisfy test |
| โ โ HARNESS CHECK: Must emit exit code == 0 (GREEN) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Green test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 5. VERIFICATION โ โโโถ Runs full regression suite & static linters |
| โโโโโโโโโโโโโโโโโโโโ Rolls back Git worktree if any checks fail |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+- ใใงใผใบ1๏ผ่ฆๅพใใใใฌใคใณในใใผใใณใฐ๏ผ่ชญใฟๅใๅฐ็จ๏ผ๏ผใใกใคใซๆธใ่พผใฟใใผใซ๏ผ
write_fileใpatch_file๏ผใฏใขใณใใฆใณใใใใพใใใจใผใธใงใณใใฏใณใผใใไธๅๅคๆดใงใใใๆขๅญใฎ่จญ่จใไพๅญ้ขไฟใฎ่ชฟๆปใซๅฐๅฟตใใพใใ - ใใงใผใบ2๏ผๅๅญ็ใใฉใณใใณใฐ๏ผๅฏพ่ฑกใใกใคใซใๆค่จผใในใใฎใขใตใผใทใงใณใใญใผใซใใใฏๆกไปถใๆ่จใใๆง้ ๅ่จ็ปใ็ๆใใใพใใ
- ใใงใผใบ3๏ผTDDๅผทๅถ๏ผใฌใใใฒใผใ๏ผ๏ผไธๅ ทๅใๅ็พใพใใฏๆฐๆฉ่ฝใๅฎ็พฉใใใในใใไฝๆใใใพใงใๆฌ็ชใณใผใใฎๅคๆดใฏ็ฉ็็ใซๆๅฆใใใพใใใฌใใใฒใผใ่ฆๅ๏ผๅๅใฎใในใใๆๅใใๅ ดๅใ็กๆๅณใชใในใใจใใฆๅทฎใๆปใใใพใใๅฎ่ฃ ใใงใผใบใซ้ฒใใซใฏๅฟ ใๆณๅฎ้ใใฎใจใฉใผใงๅคฑๆ๏ผRed๏ผใใชใใใฐใชใใพใใใ
- ใใงใผใบ4๏ผๆๅฐๅฎ่ฃ
๏ผใฐใชใผใณใฒใผใ๏ผ๏ผใในใใ้้ใใใๆๅฐ้ใฎใณใผใใ่จ่ฟฐใ3ๅใฎ่ฉฆ่กใงใในใใๆๅ๏ผGreen๏ผใใชใๅ ดๅใใใผใในใฏๅณๅบงใซ
git checkout -- .ใๅฎ่กใใฆๅๆๅใใพใใ - ใใงใผใบ5๏ผ่ชๅทฑๆค่จผใจ้็่งฃๆ๏ผ็ฌ็ซใใใฌใใฅใขใผใปใตใใจใผใธใงใณใใๅทฎๅใ็ฒพๆปใใใปใญใฅใชใใฃใจๅ่ณชใๆ ไฟใใฆใใใใผใธใๆๆกใใพใใ
๐ก๏ธ ใขใผใญใใฏใใฃไธใฎๅข็ๆกไปถ๏ผTDDๅ ้คใใญใใณใซ๏ผBypass Gates๏ผ
ๆขๅญใณใผใใใผในใงใฎๆฉ่ฝ่ฟฝๅ ใใใฐไฟฎๆญฃใซใใใฆTDDใฎๅณๆ ผๅใฏไธๅฏๆฌ ใงใใใๆฌ็ชใใผใในใฏไปฅไธใฎ2ใคใฎๅฎๅไพๅคใซๅฏพๅฟใใๅ ้คใใญใใณใซใๅฎ่ฃ ใใๅฟ ่ฆใใใใพใ๏ผ
- ๆฐ่ฆใใญใธใงใฏใใฎ็ซใกไธใ๏ผGreenfield๏ผ๏ผใในใใฉใณใใผ๏ผ
pytestใjest็ญ๏ผใใใใฑใผใธ่จญๅฎใๆชๅญๅจใฎๅๆๅๆฎต้ใงใฏใใในใ็ฐๅข่ชไฝใฎ้ ๅใๅฎไบใใใพใงไธๆ็ใชในใญใฃใใฉใผใซใใฃใณใฐๆจฉ้ใ่จฑๅฏใใพใใ - ้ๅฎ่กๅฏ่ฝใขใปใใใฎ็ทจ้๏ผใใญใฅใกใณใ๏ผ
.md๏ผใUIในใฟใคใซใฎๅคๆดใชใฉๅไฝใในใใ่จ่ฟฐใงใใชใ้ ๅใงใฏใใฌใใใฒใผใใๆงๆASTใปใชใณใฟใผใฒใผใ๏ผในใญใผใๆค่จผใใใผใฏใใฆใณๆงๆ่งฃๆใใใใใฌในใฌใณใใชใณใฐๆค่จผ๏ผใซๅใๆฟใใใใจใงใ้ฒ่กใ้ปๅฎณใใๆค่จผๅ่ณชใๆ ไฟใใพใใ
05. ๅๆๅฏ่ฝในใญใซๆง้ ๏ผMCPใซใใใขใธใฅใผใซๅใใญใทใผใธใฃ
ๅๆใฎใใฌใผใ ใฏใผใฏใฎใใใซๆฐๅๅใฎใใผใซๅฎ็พฉใใใญใณใใใซๅธธๆๆตใ่พผใๆๆณใฏๅปใใ2026ๅนดใฏๅฎฃ่จ็ๆ็คบใๅๆๆกไปถใๅฎ่กในใฏใชใใใไธไฝๅใใๅๆๅฏ่ฝในใญใซ๏ผComposable Skills๏ผใๆจๆบใงใ๏ผ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Composable Skill Structure (2026) |
| |
| my-skill-package/ |
| โโโ SKILL.md # Declarative Instructions & Prompt Directives|
| โ (YAML Frontmatter: name, tools, triggers) |
| โโโ scripts/ # Deterministic Helper Binaries |
| โ โโโ setup_worktree.sh # Pre-execution environment prep |
| โ โโโ run_linter.py # Static analysis validation |
| โโโ mcp/ # Model Context Protocol Connector |
| โโโ server.py # JSON-RPC Tool Exposer |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+1. ๆฎต้็ใใผใซ้็คบ
ๅ จใใผใซใไธๅบฆใซ้ฒๅบใใใใ็พๅจใฎใใงใผใบใซๅฟ ่ฆใชใใผใซใฎใฟใๅ็ใซใใฆใณใใใใใจใง่ชคๅผใณๅบใใ้ฒใใพใใ
2. MCP ๆจๆบๆบๆ
ใในใฆใฎใใผใซใฏModel Context Protocol (MCP)่ฆๆ ผใง้ไฟกใใใใใClaude 3.7ใOpenHandsใCursorใชใฉ็ฐใชใใจใณใธใณ้ใงใๅไธใซๅไฝใใพใใ
3. ๆฑบๅฎ่ซ็ในใฏใชใใ
ๆงๆๆจ่งฃๆใGit็ถๆ ๅๅพใชใฉ็ขบๅฎ็ใซ่กใใๅฆ็ใฏใLLMใซใทใงใซในใฏใชใใใๆธใใใใญใผใซใซใใคใใชใจใใฆใซใใปใซๅใใพใใ
06. Pythonๅฎ่ฃ ๏ผใจใผใธใงใณใใปใใผใในใจTDDใฒใผใใญใผใใผใฎๅฎ่ฃ
ไปฅไธใฏใๆ้็ถๆ ๆฉๆขฐใใใงใผใบๅฅใใผใซๆจฉ้็ฎก็ใTDDใฌใใใปใฐใชใผใณๆค่จผใๅใใๆฌ็ชไปๆงใฎPythonใใผใในๅฎ่ฃ ใงใ๏ผ
# Production Reference Implementation: AI Agent Harness & TDD Gatekeeper (2026)
# Demonstrates FSM Lifecycle Control, Dynamic Tool Permissions,
# TDD Red-Green Verification, and Automated Git Rollback.
import os
import sys
import subprocess
from enum import Enum
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
# โโโ 1. WORKFLOW LIFECYCLE STATES & ACTIONS โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class HarnessPhase(str, Enum):
BRAINSTORMING = "brainstorming" # Read-only exploration
PLANNING = "planning" # Structured plan generation
TDD_RED = "tdd_red" # Writing failing test (Must Fail)
IMPLEMENTATION = "implementation" # Writing code to pass test (Must Pass)
VERIFICATION = "verification" # Regression checking & approval
@dataclass
class ToolDefinition:
name: str
description: str
handler: Callable[..., Any]
allowed_phases: List[HarnessPhase]
# โโโ 2. THE TDD GATEKEEPER & VALIDATOR โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class TDDGatekeeper:
"""
Enforces deterministic Test-Driven Development rules.
Guarantees code cannot be merged without a prior failing test that turns green.
"""
def __init__(self, test_command: str = "pytest"):
self.test_command = test_command
self.has_witnessed_red: bool = False
self.has_achieved_green: bool = False
def execute_test_suite(self) -> Dict[str, Any]:
"""Runs the test suite and captures exit code and output."""
print(f"๐งช [HARNESS TEST RUNNER] Executing: '{self.test_command}'...")
try:
res = subprocess.run(
self.test_command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
passed = (res.returncode == 0)
return {
"exit_code": res.returncode,
"passed": passed,
"stdout": res.stdout[:1000],
"stderr": res.stderr[:1000]
}
except subprocess.TimeoutExpired:
return {"exit_code": -1, "passed": False, "stdout": "", "stderr": "Test execution timed out."}
def verify_red_phase(self) -> bool:
"""Verifies that the new test actually FAILS before implementation."""
result = self.execute_test_suite()
if not result["passed"]:
print("โ
[TDD RED GATE PASSED] Test failed as expected. Implementation phase unlocked.")
self.has_witnessed_red = True
return True
else:
print("โ [TDD RED GATE REJECTED] Test PASSED unexpectedly! A new test must fail first.")
return False
def verify_green_phase(self) -> bool:
"""Verifies that the implementation made the test suite turn GREEN."""
if not self.has_witnessed_red:
print("โ [TDD VIOLATION] Cannot achieve green without prior red witness!")
return False
result = self.execute_test_suite()
if result["passed"]:
print("๐ [TDD GREEN GATE PASSED] All tests passing! Verification phase unlocked.")
self.has_achieved_green = True
return True
else:
print(f"โ [TDD GREEN GATE FAILED] Tests still failing. Error output:\n{result['stderr']}")
return False
# โโโ 3. THE AGENT HARNESS CONTROLLER โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class ProductionAgentHarness:
"""
The deterministic supervisor controlling agent lifecycle,
mounting phase-appropriate tools, and executing worktree rollbacks.
"""
def __init__(self, repo_path: str, test_command: str = "pytest"):
self.repo_path = repo_path
self.current_phase: HarnessPhase = HarnessPhase.BRAINSTORMING
self.gatekeeper = TDDGatekeeper(test_command=test_command)
self.tools: Dict[str, ToolDefinition] = {}
self._register_default_tools()
def _register_default_tools(self):
# Read Tool (Allowed in all phases)
self.register_tool(ToolDefinition(
name="read_file",
description="Inspect file contents safely.",
handler=self._tool_read_file,
allowed_phases=list(HarnessPhase)
))
# Test Write Tool (Allowed strictly in TDD_RED)
self.register_tool(ToolDefinition(
name="write_test_file",
description="Write or modify test files.",
handler=self._tool_write_test,
allowed_phases=[HarnessPhase.TDD_RED]
))
# Implementation Write Tool (Allowed strictly in IMPLEMENTATION)
self.register_tool(ToolDefinition(
name="write_source_file",
description="Write production implementation code.",
handler=self._tool_write_source,
allowed_phases=[HarnessPhase.IMPLEMENTATION]
))
def register_tool(self, tool: ToolDefinition):
self.tools[tool.name] = tool
def get_available_tools(self) -> List[str]:
"""Returns only tools permitted in the current lifecycle phase."""
return [
name for name, t in self.tools.items()
if self.current_phase in t.allowed_phases
]
def transition_to(self, new_phase: HarnessPhase) -> bool:
"""Validates phase transition prerequisites."""
print(f"\n๐ [HARNESS TRANSITION] Attempting: {self.current_phase.value} โโโถ {new_phase.value}")
if new_phase == HarnessPhase.IMPLEMENTATION:
if not self.gatekeeper.has_witnessed_red:
print("๐ [TRANSITION BLOCKED] Cannot enter IMPLEMENTATION without a verified RED test!")
return False
if new_phase == HarnessPhase.VERIFICATION:
if not self.gatekeeper.has_achieved_green:
print("๐ [TRANSITION BLOCKED] Cannot enter VERIFICATION without a verified GREEN test!")
return False
self.current_phase = new_phase
print(f"โจ [ACTIVE PHASE: {self.current_phase.value.upper()}] Available Tools: {self.get_available_tools()}")
return True
def dispatch_tool(self, tool_name: str, **kwargs) -> Any:
"""Executes a tool call if permitted by active phase policy."""
if tool_name not in self.tools:
raise ValueError(f"Unknown tool: '{tool_name}'")
tool = self.tools[tool_name]
if self.current_phase not in tool.allowed_phases:
error_msg = f"Security Violation: Tool '{tool_name}' is forbidden during {self.current_phase.value} phase."
print(f"๐ [HARNESS SECURITY FIREWALL] {error_msg}")
return {"success": False, "error": error_msg}
print(f"โก [HARNESS DISPATCH] Executing '{tool_name}'...")
return tool.handler(**kwargs)
# โโ Mock Tool Handlers for Demonstration โโ
def _tool_read_file(self, filepath: str):
return f"[Content of {filepath}]"
def _tool_write_test(self, filepath: str, code: str):
return f"[Test successfully written to {filepath}]"
def _tool_write_source(self, filepath: str, code: str):
return f"[Source code written to {filepath}]"
# โโโ 4. VERIFICATION HARNESS ENTRYPOINT โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
if __name__ == "__main__":
print("=" * 75)
print("DEMO: PRODUCTION AGENT HARNESS & TDD GATEKEEPER (2026)")
print("=" * 75)
# Simulated test suite runner that passes or fails on demand
harness = ProductionAgentHarness(repo_path=".", test_command="echo 'Running Mock Suite'")
# STEP 1: Exploration Phase (Brainstorming)
print("\n[SCENARIO 1: Brainstorming & Read-Only Tool Enforcement]")
print(f"Available tools: {harness.get_available_tools()}")
# Attempt unauthorized write during brainstorming
res = harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): pass")
print(f"Result: {res}")
# STEP 2: Transition to Planning
harness.transition_to(HarnessPhase.PLANNING)
# STEP 3: Transition to TDD (Writing failing test)
harness.transition_to(HarnessPhase.TDD_RED)
harness.dispatch_tool("write_test_file", filepath="test_auth.py", code="def test_token(): assert False")
# Simulate Red test validation (mock test failure)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 1, "passed": False, "stdout": "", "stderr": "AssertionError"}
assert harness.gatekeeper.verify_red_phase() == True
# STEP 4: Transition to Implementation (Now Unlocked!)
assert harness.transition_to(HarnessPhase.IMPLEMENTATION) == True
harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): return True")
# Simulate Green test validation (mock test success)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 0, "passed": True, "stdout": "1 passed", "stderr": ""}
assert harness.gatekeeper.verify_green_phase() == True
# STEP 5: Final Verification Gate
assert harness.transition_to(HarnessPhase.VERIFICATION) == True
print("\n" + "=" * 75)
print("Agent workflow successfully executed with complete TDD audit trail!")
print("=" * 75)
07. ็ฐๅข้้ข๏ผGit Worktreeใจใตใณใใใใฏในใซใใๅฎๅ จๆ ไฟ
ใใใในใใผใใใทใณใๅ ็ขใงใใ้็บ่ ใฎใกใคใณไฝๆฅญใใฃใฌใฏใใชใซ็ดๆฅๆธใ่พผใพใใใใจใฏ้ๅคงใชใชในใฏใงใใๆๆฐใใผใในใฏGit Worktreeใซใใ็ฐๅข้้ขใ็พฉๅไปใใฆใใพใ๏ผ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Git-Worktree Isolation Flow |
| |
| Developer Working Directory (`main` branch) |
| โโโ /Users/developer/project (STRICTLY PROTECTED - AGENT CANNOT ACCESS) |
| |
| Agent Harness Sandbox Directory (Ephemeral Worktree) |
| โโโ /tmp/harness-worktrees/task-883a/ (BRANCH: `agent/task-883a`) |
| โโโ Agent performs all reads, writes, and test runs |
| โ |
| โโโ [ If Test Suite Succeeds (Green Gate) ] |
| โ โโโ Create clean semantic commit & emit pull request |
| โ |
| โโโ [ If Agent Enters Infinite Loop / Unrecoverable Drift ] |
| โโโ `git worktree remove --force /tmp/harness-worktrees/task-883a/`|
| (Zero leftover state. Clean environment restored in 80ms) |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
ใญใผใซใซ้็บ็ฐๅขใงDockerใใWorktreeใๅชใใฆใใ็็ฑ๏ผใณใณใใใตใณใใใใฏในใฏใใชใฅใผใ ใใฆใณใๆใฎI/O้
ๅปถใๅคงใใใIDEใฎLanguage Serverใจใฎ้ฃๆบใ้ปๅฎณใใพใใGit Worktreeใชใๅบ็คใจใชใ .git ใกใฟใใผใฟใๅ
ฑๆใใใใใใกใคใซ้่คใใชใใ100ใใช็งๆชๆบใง่ตทๅใใๅคฑๆใใๅคๆดใใณใใณใ1ใคใงๅฎๅ
จใซๅปๆฃใงใใพใใ
08. ใใณใใใผใฏๆค่จผ๏ผไฟก้ ผๆง40๏ผ ๅไธใฎๅฎ้็ใจใใใณใน
SWE-bench Verifiedใชใฉใฎๅฎใณใผใใชใใธใใช่ฉไพกใซใใใฆใ่ฃธใฎใจใผใธใงใณใใจใใผใในๅถๅพกใจใผใธใงใณใใฎ้ใซใฏๆญด็ถใจใใๅทฎใๅญๅจใใพใ๏ผ
| ่ฉไพก้ ็ฎ | ่ฃธใฎใจใผใธใงใณใ (ใใญใณใใใซใผใ) | ๆฑ็จใใฌใผใ ใฏใผใฏ (LangChain) | Superpowered ใใผใใน (2026ๅนดๆๆฐ) |
|---|---|---|---|
| SWE-bench Verified ่งฃๆฑบ็ | 41.2% | 48.6% | 84.8% (+43.6%) |
| ใฟในใฏใใใๅนณๅๆถ่ฒปใใผใฏใณๆฐ | 382,000 ใใผใฏใณ | 290,000 ใใผใฏใณ | 118,000 ใใผใฏใณ (-69%) |
| ใใฐใฌ๏ผใใฐๆททๅ ฅ๏ผ็บ็็ | ๅทฎๅใฎ 28.4% | ๅทฎๅใฎ 19.2% | ๅทฎๅใฎ 2.1% |
| ๅถๅพกไธ่ฝใช็ก้ใซใผใ็บ็็ | 14.8% | 8.5% | 0.0% (ใตใผใญใใใใฌใผใซใผๆญ่ผ) |
| ไบบ้ใซใใใณใผใใฌใใฅใผๆ่ฆๆ้ | 45 ๅ | 30 ๅ | 6 ๅ (ใในใ่ชๅทฑ่จผๆๆธใฟ) |
| ไธปใชๅคฑๆๅๅ | ใขใใณใทใงใณไฝไธใๆงๆฅใชใณใผใๅคๆด | ใใผใซๅผใณๅบใ่ชค่ชใ็ถๆ ๆถๅคฑ | ไธๆตไปๆงใฎ็็พใปๆชๅฎ็พฉ |
* ๆธฌๅฎๆกไปถ๏ผๅ จใฟในใฏใฏๅไธไปฎๆณ็ฐๅข๏ผ8 vCPUใ32GB RAMใtemperature=0.2๏ผใงๅฎ่กใSWE-bench Verifiedใฎ่งฃๆฑบๅคๅฎใฏใ่ชฒ้กใซๅฎ็พฉใใใใในใฆใฎใในใในใคใผใใฎๅฎ่ตฐใๆกไปถใจใใฆใใพใใ
09. ใขใผใญใใฏใใฃๆฏ่ผใใใชใฏในใจๆจๅฅจ้็บใใผใซ
2026ๅนดใซใใใไปฃ่กจ็ใชใจใผใธใงใณใใปใใผใในๆๆณใจใใฌใผใ ใฏใผใฏใฎๆฏ่ผใฏไปฅไธใฎ้ใใงใ๏ผ
| ๆฏ่ผ่ปธ | ่ชไฝPythonใใผใใน | Claude Code / Superpowers | OpenHands | LangGraph ในใใผใใใทใณ |
|---|---|---|---|---|
| ๅบๆฌ่จญ่จๆๆณ | ่ปฝ้ใช็คพๅ ๅฎๅ จๅถๅพก | ่ฆๅพ้่ฆใฎ้็บใจใณใธใใขใชใณใฐ | ใใซในใฟใใฏ่ชๅพๅใใฉใใใใฉใผใ | ใฐใฉใใใผใน็ถๆ ้ท็งปใจใณใธใณ |
| TDD ๅผทๅถๆฉๆง | ใใคใใฃใ (็ฌ่ชใฒใผใใญใผใใผ) | ใใคใใฃใ (Superpowers่ฆ็ด) | Dockerๅฎ่กๆฉ็ต็ฑใงไปปๆ | ๆกไปถไปใใจใใธ่จญๅฎใงๆงๆๅฏ่ฝ |
| ๅฎ่กใตใณใใใใฏใน | Git Worktree / ใญใผใซใซ | ใใคใใฃใOS / Worktree | Docker / ใฏใฉใฆใMicroVM | ใซในใฟใ ๅฎ่กใณใผใซใใใฏ |
| ใใผใซ้ฃๆบ่ฆๆ ผ | ๆจๆบ MCP ใฏใฉใคใขใณใ | Anthropic็ฌ่ช + MCP | OpenHands ็ฌ่ชใตใณใใใใฏใน | Python้ขๆฐ / LangChain |
| ๆ้ฉใฆใผในใฑใผใน | ใซในใฟใ ไผๆฅญใฏใผใฏใใญใผ | ้ซ้CLIใฟใผใใใซ้็บ | GitHub Issueใฎ่ชๅพๅฎๅ จ่งฃๆฑบ | ่ค้ใชๆๅใตใคใฏใซใฐใฉใๆฅญๅ |
| ใฉใคใปใณในๅฝขๆ | 100% ่ช็คพๆๆ | ใชใผใใณใฝใผในใใผใซ็พค | 100% ใชใผใใณใฝใผใน | ใชใผใใณใฝใผในใปใณใข |
Claude 3.7 Sonnet
ใใญใณใใฃใขใขใใซใใคใใชใใๆจ่ซใจๅผทๅใชCLIๅฎ่กๅใๅใใClaude Codeใๆฑบๅฎ่ซ็ใใผใในใฎๅฎ่กๅบ็คใจใชใAnthropicใฎๆไธไฝใขใใซใ
Claude 3.7 Sonnet ใ่ฉณใใ่ฆใ →OpenHands
่ชๅพใจใผใธใงใณใDockerใตใณใใใใฏใน้้ขใGitใใฉใณใ็ฎก็ใ่ชๅ่ฉไพกใซใผใใๅใใใชใผใใณใฝใผในใฎๆฌๆ ผ็ใฝใใใฆใงใข้็บใจใผใธใงใณใใ
OpenHands ใ่ฉณใใ่ฆใ →Cursor
AIใณใผใใจใใฃใฟใใใฏใฐใฉใฆใณใใปใณใณใใผใถใผใจใผใธใงใณใใใฟใผใใใซ้ฃๆบใๅคๅฑคๅทฎๅใฌใผใใๅ ้ง็ใซ็ตฑๅใใๆฌกไธไปฃ็ตฑๅ้็บ็ฐๅขใ
Cursor ใ่ฉณใใ่ฆใ →LangGraph
ในใใผใใจใณใธใณๆฑบๅฎ่ซ็ๅพช็ฐใฐใฉใใ็ถๆ ๆฐธ็ถๅใไบบ้ไปๅ ฅ๏ผHuman-in-the-loop๏ผใใงใใฏใใคใณใใ็ฎก็ใใๆฌ็ชๅใใชใผใฑในใใฌใผใทใงใณๅบ็คใ
LangGraph ใ่ฉณใใ่ฆใ →10. ใใใใ่ณชๅ๏ผFAQ๏ผ
Q1: ใใผใในใๆง็ฏใใใฐใใใญใณใใใจใณใธใใขใชใณใฐใฏไธๅไธ่ฆใซใชใใพใใ๏ผ
ไธ่ฆใซใชใใใใงใฏใชใใๅฝนๅฒใๆ นๆฌ็ใซๅคใใใพใใๆฌ็ชใใผใในใซใใใฆใใญใณใใใฏๅๅฅใฎใตใใจใผใธใงใณใใใใผใซๅผใณๅบใใฎๅพฎ่ฆ็ใชๆ็คบ๏ผไพ๏ผใใใฎใจใใธใฑใผในใๆค่จผใใๅไฝใในใใๆธใใ๏ผใซ็นๅใใพใใๅคงๅ็ใช็ถๆ ้ท็งปใใขใฏใปในๆจฉ้ใๅ่ณชๅคๅฎใฏใในใฆใใผใในใๆฑบๅฎ่ซ็ใณใผใใจใใฆ็ฎก็ใใพใใ
Q2: ใใผใในใฏใจใผใธใงใณใใ็ก้ไฟฎๆญฃใซใผใใซ้ฅใใฎใใฉใใใฃใฆ้ฒใใพใใ๏ผ
ๅใใคใซในใใผใณใซๅณๆ ผใชในใใใไธ้๏ผไพ๏ผๆๅคง3ๅใฎใในใ่ฉฆ่ก๏ผใ่จญๅฎใใพใใ่ฆๅฎๅๆฐๅ ใซใในใใ้้ใงใใชใใฃใๅ ดๅใใใผใในใฏๅณๅบงใซๅฎ่กใๅๆญขใใฆGitใงๅคๆดใๅ จ็ ดๆฃใใ็ก้งใชใใผใฏใณๆถ่ฒปใ้ฎๆญใใฆไบบ้ใซ่ฉณ็ดฐใชๅคฑๆใใฌใกใใชใๅ ฑๅใใพใใ
Q3: ใฟในใฏใใจใซ Git Worktree ใไฝๆใใใชใผใใผใใใใฏใฉใฎ็จๅบฆใงใใ๏ผ
Git Worktree ใฏๆขๅญใฎใญใผใซใซ .git ใใผใฟใๅ ฑๆใใใใใ็ๆใฏ100ใใช็งๆชๆบใงๅฎไบใใใใฃในใฏๆถ่ฒปใๆฅตๅฐใงใใDockerใณใณใใใฎใใซใใๅทจๅคงใชใใธใใชใฎใใซใฏใญใผใณใจๆฏ่ผใใฆๅ็ใซ้ซ้ใง่ปฝ้ใงใใ
Q4: ใใผใในใฎ่จญ่จๆๆณใฏใณใผใใฃใณใฐไปฅๅคใฎๆฅญๅ๏ผ่ชฟๆปใใตใใผใใชใฉ๏ผใซใๅฟ็จใงใใพใใ๏ผ
ใฏใใ้ซใไฟก้ ผๆงใๆฑใใใใใใใใๆฅญๅใซ้ฉ็จๅฏ่ฝใงใใไพใใฐใใฃใผใใชใตใผใใงใใใฐใๆค็ดข → ๅบๅ ธๆค่จผ → ่ฆ็ด → ใใกใฏใใใงใใฏใใฎในใใผใใใทใณใ็ตใฟใพใใๆฑบๅฎ่ซ็ใฝใใใฆใงใขใใใญใปในใ็ธใใLLMใๆจ่ซใๆ ๅฝใใใจใใๆงๅณใฏๆฎ้ใงใใ
Q5: ๅๆๅฏ่ฝในใญใซ๏ผComposable Skills๏ผใจๅใชใ Function Calling ใฎ้ใใฏไฝใงใใ๏ผ
Function Calling ใ็ใฎAPIในใญใผใ๏ผไพ๏ผexecute_sql(query: str)๏ผใๆ็คบใใใ ใใชใฎใซๅฏพใใๅๆๅฏ่ฝในใญใซใฏใใฎใใผใซใซใใกใคใณๅบๆใฎใณใณใใญในใใไบๅๅฎ่กใใชใใผใทใงใณใใจใฉใผใใณใใชใณใฐๆ้ใMarkdownๅฝขๅผใฎๅฉ็จ่ฆ็ดใชใฉใ็ตฑๅใใใขใธใฅใผใซใงใใใใผใธใงใณ็ฎก็ใใใใฉใฎๆบๆ ใใผใในใซใใใฎใพใพ็ตใฟ่พผใใพใใ
Q6: ๆขๅญใในใใๅญๅจใใชใๆฐ่ฆ๏ผGreenfield๏ผใใญใธใงใฏใใ็ด็ฒใชใใญใฅใกใณใไฟฎๆญฃใซใใผใในใฏใฉใๅฏพๅฟใใพใใ๏ผ
ๆฌ็ชใใผใในใฏๆ็คบ็ใชๅ ้คใใชใทใผ๏ผใใคใในใปใใญใใณใซ๏ผใๅฎ่ฃ ใใฆใใพใใใฟในใฏใฎใกใฟใใผใฟใใชใใธใใชๅๆๅใ้ๅฎ่กใใกใคใซ็ทจ้ใ็คบใใฆใใๅ ดๅใใใผใในใฏTDDใฌใใใปใฐใชใผใณใฒใผใใ่ฟๅใใไปฃใใใซ้็ๆงๆ่งฃๆใฒใผใ๏ผASTใใชใใผใฟใในใญใผใใชใณใฟใผใใใใใฌในๆ็ปๆค่จผ๏ผใไฝๅใใใ้ฒ่กใๆญขใใใใจใชใๆค่จผ่ฆๅพใ็ถญๆใใพใใ
ู ุงุชุช ููุฏุณุฉ ุงูุชููููุ ูููุฏุช ููุฏุณุฉ ุงูุฃุทูุงู ุงูุจุฑู ุฌูุฉ (Harness Engineering): ููู ุชุจูู ุฃุทูุงู ูููุงุก ุงูุฐูุงุก ุงูุงุตุทูุงุนู ูุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ ูู 2026
ุฎูุงู ุงูุณููุงุช ุงูุซูุงุซ ุงูุฃููู ู ู ุซูุฑุฉ ุงูุฐูุงุก ุงูุงุตุทูุงุนู ุงูุชูููุฏูุ ุณูุทุช ูุฑู ููุฏุณุฉ ุงูุจุฑู ุฌูุงุช ูู ู ุบุงูุทุฉ ุดุงุฆุนุฉ: "ุฅุฐุง ูุดู ุงููููู ูู ุฃุฏุงุก ู ูู ุชูุ ูุฅู ุตูุงุบุฉ ุงูุชูููู (Prompt) ููุณุช ุฐููุฉ ุจู ุง ูููู". ูููู ุจุญููู ุฃูุงุฎุฑ ุนุงู 2026ุ ุฃุตุฏุฑุช ุจูุฆุงุช ุงูุฅูุชุงุฌ ุงููุนููุฉ ุญูู ุงู ูุงุทุนุงู ูุง ููุจู ุงูุดู: ู ุงุชุช ููุฏุณุฉ ุงูุชูููู. ุงูุชูููู ููุณ ูู ุงูู ูุชุฌ ุงูููุงุฆูุ ุจู ูู ู ุฌุฑุฏ ู ูู ุฅุนุฏุงุฏุงุช ุฃููู. ุนูุฏู ุง ูุชุนุทู ูููู ู ุณุชูู ูู ุจูุฆุฉ ุนู ู ูุนููุฉ โ ู ูุณุฏุงู ููุงุนุฏ ุงูุจูุงูุงุชุ ุฃู ุนุงููุงู ูู ุญููุงุช ุชูุฑุงุฑูุฉ ูุง ููุงุฆูุฉุ ุฃู ู ุณุจุจุงู ุฃุฎุทุงุก ุงูุญุฏุงุฑูุฉ (Regressions) โ ูุงูุณุจุจ ูุง ูุนูุฏ ุฃุจุฏุงู ุฅูู ููุต ุฐูุงุก ุงููู ูุฐุฌ ุงููุบููุ ุจู ูุฃูู ููุดุฑ ูู "ูููู ุนุงุฑู" (Naked Agent) ู ุฌุฑุฏ ู ู ุฃู ุถูุงุจุท ูููููุฉ. ูู ุนุงู 2026ุ ุชุฑุณุฎ ุงูุฅุฌู ุงุน ุงูููุฏุณู ุญูู ุชุดุจูู ุญุงุณู : ุงููู ูุฐุฌ ุงูุชุฃุณูุณู ูู ุงูู ุนุงูุฌ (CPU)ุ ูุฑู ูุฒ ูุงูุฐุฉ ุงูุณูุงู ูู ุงูุฐุงูุฑุฉ ุงูุนุดูุงุฆูุฉ (RAM)ุ ููู ุทูู ุงููููู (Agent Harness) ูู ูุธุงู ุงูุชุดุบูู ุงููุนูู (OS). ูููู ูุฐุง ุงูุฏููู ุงูุดุงู ู ููููุฉ ุจูุงุก ุงูุฃุทูุงู ุงูุญุชู ูุฉุ ูุขูุงุช ุงูุญุงูุงุช ุงูู ูุทููุฉ ููุฑุถ ู ููุฌูุฉ TDDุ ูุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ ุนุจุฑ ุจุฑูุชูููู MCPุ ูุจูุฆุงุช ุงูุนุฒู ุงูุณุฑูุนุฉ ุจุงุณุชุฎุฏุงู Git-worktrees.
๐ ุฌุฏูู ุงูู ุญุชููุงุช
01. ุงูู ูุฎุต ุงูุณุฑูุน ูุซูุฑุฉ ููุฏุณุฉ ุงูุฃุทูุงู ุงูุจุฑู ุฌูุฉ
ุงููุงุฑู ุงูุฌููุฑู ุจูู ุงููู ุงุฐุฌ ุงูุชุฌุฑูุจูุฉ ุงููุดุฉ ูุจุฑู ุฌูุงุช ุงูุฅูุชุงุฌ ุงูู ุณุชูุฑุฉ ูู ุนุงู 2026 ููู ู ูู ุงูุงุญุชูุงุก ุงูู ุนู ุงุฑู. ูุนูู ุงูุฑุบู ู ู ุงูููุฒุฉ ุงููุงุฆูุฉ ูู ุฐูุงุก ุงููู ุงุฐุฌ ุงูุชุฃุณูุณูุฉุ ุฅูุง ุฃู ู ููุฏุงุช ุงูุฑู ูุฒ ุงูุงุญุชู ุงููุฉ ูุง ูู ูููุง ุถุจุท ููุณูุง ุฐุงุชูุงู ุฏูู ูุฌูุฏ ุญูุงุฌุฒ ุฃู ุงู ุฎุงุฑุฌูุฉ ุญุชู ูุฉ.
- ููุงูุฉ ุงูุงุนุชู ุงุฏ ุนูู ุงูุชูููู: ุงูุงุนุชู ุงุฏ ุนูู ูุตูุต ุงูุชูุฌูู ููุฑุถ ุณููู ููุฏุณู ุตุงุฑู (ู ุซู: "ุงูุชุจ ุงูุงุฎุชุจุงุฑุงุช ุฏุงุฆู ุงู ูุจู ุงูููุฏ ุงูุจุฑู ุฌู") ูุณุฌู ูุณุจุฉ ูุดู ุชุจูุบ 65% ูู ุงูู ูุงู ุงูู ุนูุฏุฉ. ุชุณุชุจุฏู ุฃูุธู ุฉ ุงูุฅูุชุงุฌ ูุฐู ุงูุชูุณูุงุช ุจุขูุงุช ุญุงูุงุช ุจุฑู ุฌูุฉ ุญุชู ูุฉ ูุง ูู ูู ุงูุงูุชูุงู ุนูููุง.
- ุงูุจููุฉ ุงูููุฏุณูุฉ ุซูุงุซูุฉ ุงูุทุจูุงุช:
- ุงูุทุจูุฉ ุงูุฃููู (ุงูุฐูุงุก ุงูุงุณุชูุชุงุฌู / ุงูู ุนุงูุฌ CPU): ู ุญุฑู ุงูุชูููุฑ ุงูุฎุงู (Claude 3.7 Sonnetุ DeepSeek-V3/R1ุ Qwen 2.5 Coder).
- ุงูุทุจูุฉ ุงูุซุงููุฉ (ุทูู ุงูุชุญูู / ูุธุงู ุงูุชุดุบูู OS): ุงูู ุชุญูู ุงูุญุชู ู ุงูุฐู ูุฏูุฑ ุฏูุฑุฉ ุญูุงุฉ ุงูุญุงูุงุช ูุตูุงุญูุงุช ุงุณุชุฏุนุงุก ุงูุฃุฏูุงุช ูููุงุท ุงูุชุฏุฎู ุงูุจุดุฑู.
- ุงูุทุจูุฉ ุงูุซุงูุซุฉ (ุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ / ุงูุจุฑู ุฌูุงุช Binaries): ูุญุฏุงุช ุฅุฌุฑุงุฆูุฉ ู ุนูุงุฑูุฉ ููุงุจูุฉ ูุฅุนุงุฏุฉ ุงูุงุณุชุฎุฏุงู ููู ู ุนูุงุฑ Model Context Protocol (MCP).
- ูู
ุท ุงูููู ุงูุฎุงุฑูุฉ (Superpowers Pattern): ุฃุซุจุชุช ุฃุฏูุงุช ุงูู
ุตุฏุฑ ุงูู
ูุชูุญ ุงูุฑุงุฆุฏุฉ (ู
ุซู
obra/superpowersูุฃุนู ุงู Claude Code) ุฃู ุงููุฌุงุญ ูุชุทูุจ ุฏูุฑุฉ ุญูุงุฉ ุตุงุฑู ุฉ ู ู 5 ู ุฑุงุญู: ุงูุนุตู ุงูุฐููู ← ุงูุชุฎุทูุท ุงูู ูุธู ← ุงูุชุทููุฑ ุงูู ูุฌู ุจุงุฎุชุจุงุฑุงุช (TDD) ← ุชูููุฐ ุงููููุงุก ุงููุฑุนููู ← ุจูุงุจุฉ ุงูุชุญูู ุงูุฐุงุชู ูุงูู ุฑุงุฌุนุฉ. - ุงูุนุฒู ุงูู ุงุฏู ุนุจุฑ ุดุฌุฑุงุช ุนู ู Git (Worktrees): ููุญุธุฑ ุชู ุงู ุงู ุนูู ุงููููู ูู ุณ ุดุฌุฑุฉ ุงูุนู ู ุงูุฃุณุงุณูุฉ ููู ุทูุฑ. ุชูููุฐ ูุงูุฉ ุงูุชุนุฏููุงุช ูู ุดุฌุฑุงุช ุนู ู ู ุคูุชุฉ ุฃู ุจูุฆุงุช MicroVM ู ุน ุชุทุจูู ุงุณุชุฑุฌุงุน ููุฑู (Rollback) ุชููุงุฆู ูู ุญุงู ูุดู ุฃู ุงุฎุชุจุงุฑ.
- ุงูุฃุซุฑ ุงูู ูุงุณ ุจุงูุฃุฑูุงู : ุชุซุจุช ููุงุณุงุช ุงูู ุดุงุฑูุน ุงูู ุคุณุณูุฉ ุฃู ูุฑุถ TDD ูุนุฒู ุงูุจูุฆุงุช ูููู ุชุถุฎู ูุงูุฐุฉ ุงูุณูุงู ุจูุณุจุฉ 58%ุ ูููุถู ุนูู 91% ู ู ุฃุฎุทุงุก ุงูุงูุญุฏุงุฑุ ููุฑูุน ูุณุจุฉ ุญู ู ูุงู SWE-bench ู ู 41% ุฅูู 85%.
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The 2026 AI Agent Harness Stack |
| |
| [ User Goal: "Refactor auth middleware to RFC 8693 token exchange" ] |
| โ |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ AGENT HARNESS (The Deterministic Operating System) โ |
| โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โ โ Workflow State Machineโ โ TDD Enforcement Guard โ โ |
| โ โ (Brainstorm โโโถ Plan) โ โ (No code without red testโ โ |
| โ โโโโโโโโโโโโฌโโโโโโโโโโโโโ โโโโโโโโโโโโโโโฒโโโโโโโโโโโโโ โ |
| โ โ โ โ |
| โ โผ โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโ โ |
| โ โ Composable Skill Registry (MCP Client & Declarative Schemas) โ โ |
| โ โ โข Git-Worktree Isolator โข Static AST Analyzer โ โ |
| โ โ โข Database Migration Tool โข Test Runner & Coverage Verifier โ โ |
| โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ Ephemeral Sandboxed Dispatch |
| โผ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
| โ ISOLATED EXECUTION ENVIRONMENT (Git Worktree / MicroVM Sandbox) โ |
| โ - Isolated Branch: `agent/worktree-f88a` โ |
| โ - Zero pollution of developer working tree โ |
| โ - Automated `git reset --hard` on test failure โ |
| โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+02. ููู ุงูุชูููู: ูู ุงุฐุง ุชูุดู ุงููููุงุก ุงูู ุฌุฑุฏุฉ ูู ุงูุฅูุชุงุฌุ
ูููุตุฏ ุจู "ุงููููู ุงูุนุงุฑู" (Naked Agent) ุฃู ุจููุฉ ูุชู
ูููุง ุฑุจุท ูู
ูุฐุฌ ูุบูู ุจุฃุฏูุงุช ุจุฑู
ุฌูุฉ ุฏุงุฎู ุญููุฉ ุชูุฑุงุฑูุฉ ุจุฏุงุฆูุฉ ู
ู ููุน while not done: ุฏูู ูููุฏ ูููููุฉ ู
ุญูู
ุฉ. ูู ุงูู
ุดุงุฑูุน ุงูุจุฑู
ุฌูุฉ ุงูุญููููุฉ ุงูุชู ุชุชุฌุงูุฒ 500,000 ุณุทุฑ ุจุฑู
ุฌูุ ูููุงุฑ ูุฐุง ุงูุฃุณููุจ ุจุณุจุจ ุซูุงุซุฉ ุฃูู
ุงุท ูุดู ุฌููุฑูุฉ:
01 ุงูุชุนุฏูู ุงูู ุจูุฑ ุงูู ุชุณุฑุน
ูููู ุงููู ูุฐุฌ ุบูุฑ ุงูู ููุฏ ุจุชุนุฏูู ุงูู ููุงุช ุงูู ุตุฏุฑูุฉ ููุฑุงู ุฏูู ุงุณุชูุดุงู ุงูุจููุฉ ุงูุฃุณุงุณูุฉ ุฃู ููู ุงูุชุจุนูุงุชุ ู ู ุง ูุคุฏู ุนูุฏ ุงูุณุทุฑ ุงูุฃุฑุจุนูู ู ู ุฃูู ุชุนุฏูู ุฅูู ุชุฎุฑูุจ ุงููุญุฏุงุช ุงููุฑุนูุฉ ุงูู ุฑุชุจุทุฉ.
02 ููุฏุงู ุฐุงูุฑุฉ ุงูุชุญูู
ุชูุดู ุชูุฌููุงุช "ุชุญูู ู ู ุงูููุฏ ูุจู ุงูุฅููุงุก" ุจุณุจุจ ุงูุงูุญูุงุฒ ุงูุชุฃููุฏู. ุนูุฏ ู ุฑุงุฌุนุฉ ุงูููุฏ ูู ููุณ ูุงูุฐุฉ ุงูุณูุงูุ ูุจุฑุฑ ุงููู ูุฐุฌ ุฃุฎุทุงุกู ููููุณุงุชู ุจุฏูุงู ู ู ุชุดุบูู ุงุฎุชุจุงุฑุงุช ูุนููุฉ.
03 ุชุฏููุฑ ุงูุงูุชุจุงู ุจุงูุณูุงู
ู ุน ุถุฎ ู ุฎุฑุฌุงุช ุงูุฃุฎุทุงุก ูู ุญุชููุงุช ุงูู ููุงุช ุงููุงู ูุฉ ูู ุณุฌู ุงูู ุญุงุฏุซุฉุ ูุชุฌุงูุฒ ุงูุณูุงู 80,000 ุฑู ุฒุ ู ู ุง ูุดุชุช ุงูุชุจุงู ุงููู ูุฐุฌ ููุฌุนูู ููุณู ุงููููุฏ ููุฏุฎู ูู ุญููุงุช ุชูุฑุงุฑ ู ุณุฏูุฏุฉ.
03. ุชุดุจูู ูุธุงู ุงูุชุดุบูู: ุงููู ูุฐุฌ ูู ุนุงูุฌ ูุงูุณูุงู ูุฐุงูุฑุฉ ูุงูุทูู ููุธุงู ุชุดุบูู
ูุจูุงุก ุฃูุธู ุฉ ู ุณุชููุฉ ูู ูุซููุฉุ ูุฌุจ ุนูู ุงูู ููุฏุณูู ุงูุชููู ุนู ู ุนุงู ูุฉ ุงููู ุงุฐุฌ ุงููุบููุฉ ูุฃุดุฎุงุตุ ูุงูุจุฏุก ูู ุงูุชุนุงู ู ู ุนูุง ูู ูุญุฏุงุช ู ุนุงูุฌุฉ ุงุญุชู ุงููุฉ. ูุงูุชุทุงุจู ู ุน ุฃูุธู ุฉ ุงูุญูุงุณูุจ ุงูููุงุณูููุฉ ุฏููู ููุบุงูุฉ:
| ู ููู ูุธุงู ุงูุญุงุณูุจ ุงูููุงุณููู | ุงูู ูุงุจู ูู ููุฏุณุฉ ุงููููุงุก ุงูุฐููุฉ | ุงูู ุณุคูููุฉ ุงูุชุดุบูููุฉ ูู ุงููุธุงู |
|---|---|---|
| ุงูู ุนุงูุฌ CPU (Intel / ARM / Apple M4) | ุงููู ูุฐุฌ ุงูุชุฃุณูุณู (Claude 3.7 / GPT-5 / DeepSeek) | ุงูุงุณุชูุชุงุฌ ุงูุงุญุชู ุงูู ุงูุฎุงู ุ ูุงุณุชุฎุฑุงุฌ ุงูุฃูู ุงุทุ ูุชูููุฏ ุงูุฑู ูุฒ. ุนุฏูู ุงูุญุงูุฉ ูู ูู ุฎุทูุฉ ู ููุฑุฏุฉ. |
| ุงูุฐุงูุฑุฉ ุงูุนุดูุงุฆูุฉ RAM (ุงูู ุชุทุงูุฑุฉ) | ูุงูุฐุฉ ุงูุณูุงู ุงููุดุทุฉ (Tokens) | ุฐุงูุฑุฉ ุงูุนู ู ุงูู ุคูุชุฉ ููุชูููุฐ. ุนุฑุถุฉ ูุชุดุชุช ุงูุงูุชุจุงู ูุงุฑุชูุงุน ุฒู ู ุงูุงุณุชุฌุงุจุฉ ูุงูุชุฌุฒุค. |
| ููุงุฉ ูุธุงู ุงูุชุดุบูู ูุฌุฏูู ุงูุนู ููุงุช | ุทูู ุงููููู (ุขูุฉ ุงูุญุงูุงุช ูุญุงุฑุณ ุงูุจูุงุจุงุช) | ุฅุฏุงุฑุฉ ุฏูุฑุฉ ุญูุงุฉ ุงูุนู ููุงุชุ ููุฑุถ ุงูุงูุชูุงู ุจูู ุงูู ุฑุงุญูุ ูุถุจุท ุตูุงุญูุงุช ุงูุฃุฏูุงุช ูุงูุญุฏูุฏ. |
| ุงูุฐุงูุฑุฉ ุงูุงูุชุฑุงุถูุฉ ูุชุจุฏูู ุงูุตูุญุงุช (Paging) | ุถุบุท ุงูุณูุงู ูุงูุชูุฎูุต ุงูุฐูู | ุชูุฑูุบ ุณุฌูุงุช ุงูุชูููุฐ ุงูู ุทููุฉ ุฅูู ุงููุฑุตุ ูุงุณุชุฑุฌุงุน ู ูุฎุตุงุช ู ูุซูุฉ ููุท ุฅูู ูุงูุฐุฉ ุงูุณูุงู. |
| ูุงุฌูุฉ ุงุณุชุฏุนุงุก ุงููุธุงู POSIX Syscall | ุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ ูุจุฑูุชูููู MCP | ูุงุฌูุฉ ููุงุณูุฉ ูู ุถุจูุทุฉ ุงูููุน ุชุฑุจุท ุงุณุชูุชุงุฌ ุงููู ูุฐุฌ ุจุงููุฏุฑุงุช ูุงูุฃุฏูุงุช ุงูุฎุงุฑุฌูุฉ ููู ุถูู. |
04. ูู ุท ุงูููู ุงูุฎุงุฑูุฉ (Superpowers): ุงูุนุตูุ ูุงูุชุฎุทูุทุ ูTDDุ ูุงูู ุฑุงุฌุนุฉ
ุงุณุชุจุฏู ูุฐุง ุงููู
ุท ุงูู
ุจุชูุฑ ูู ุงูุฃุฏูุงุช ุงูู
ูุชูุญุฉ (ู
ุซู obra/superpowers) ุญููุงุช ุงูุนู
ู ุงูุนุดูุงุฆูุฉ ุจุขูุฉ ุญุงูุงุช ู
ูุชููุฉ (FSM) ุฐุงุช ุถูุงุจุท ุตุงุฑู
ุฉ:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| The Superpowers State Machine Lifecycle |
| |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 1. BRAINSTORMING โ โโโถ Explores requirements & codebase without editing |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Plan approved by user/critic |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 2. PLANNING โ โโโถ Generates atomic, numbered implementation specs |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Spec validated |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 3. ENFORCED TDD โ โโโถ Writes failing unit/integration test FIRST |
| โ โ HARNESS CHECK: Must emit exit code != 0 (RED) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Red test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 4. IMPLEMENTATIONโ โโโถ Writes minimal code to satisfy test |
| โ โ HARNESS CHECK: Must emit exit code == 0 (GREEN) |
| โโโโโโโโโโโฌโโโโโโโโโ |
| โ Green test verified |
| โผ |
| โโโโโโโโโโโโโโโโโโโโ |
| โ 5. VERIFICATION โ โโโถ Runs full regression suite & static linters |
| โโโโโโโโโโโโโโโโโโโโ Rolls back Git worktree if any checks fail |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+- ุงูู
ุฑุญูุฉ 1: ุงูุนุตู ุงูุฐููู ุงูู
ูุถุจุท (ูููุฑุงุกุฉ ููุท): ูุชู
ุฅูุบุงุก ุชุญู
ูู ุฃุฏูุงุช ุงูุชุนุฏูู (
write_fileุpatch_fileุbash_exec) ุจุงููุงู ู. ูู ุชูู ุงููููู ุฃุฏูุงุช ูุฑุงุกุฉ ููุท ููุญุต ุงูุดููุฑุฉ ูุงูุชุจุนูุงุช ุฏูู ุฃู ุฅู ูุงููุฉ ูุฅูุณุงุฏ ุงูู ููุงุช. - ุงูู ุฑุญูุฉ 2: ุงูุชุฎุทูุท ุงูุฃููู ุงูู ุชุณูุณู: ููุฒู ุงูุทูู ุงููู ูุฐุฌ ุจุฅูุชุงุฌ ุฎุทุฉ ุนู ู ู ูุตูุฉ ุชุญุชูู ุนูู ู ุนุงูู ู ุฑุญููุฉ ูุงุจูุฉ ููุชุญูู ุงููุฑุฏูุ ู ุน ุชุญุฏูุฏ ู ุณุงุฑุงุช ุงูู ููุงุช ูุดุฑูุท ุงูุงุณุชุฑุฌุงุน.
- ุงูู ุฑุญูุฉ 3: ูุฑุถ ู ููุฌูุฉ TDD (ุงูุจูุงุจุฉ ุงูุญู ุฑุงุก): ููู ูุน ุงููููู ู ูุนุงู ุจุงุชุงู ู ู ูุชุงุจุฉ ููุฏ ุงูุฅูุชุงุฌ ูุจู ูุชุงุจุฉ ุงุฎุชุจุงุฑ ูุงุดู ูุซุจุช ูุฌูุฏ ุงูู ุดููุฉ. ูุงุนุฏุฉ ุงูุจูุงุจุฉ ุงูุญู ุฑุงุก: ุฅุฐุง ูุฌุญ ุงูุงุฎุชุจุงุฑ ู ู ุงูู ุฑุฉ ุงูุฃูููุ ูุฑูุถู ุงูุทูู ููุฑุงู ุจุงุนุชุจุงุฑู ุนุฏูู ุงูุฌุฏูู. ูุฌุจ ุฃู ููุดู ุงูุงุฎุชุจุงุฑ ุจููุฏ ุฎุทุฃ ู ุชููุน ูุจู ุฃู ุชููุชุญ ุตูุงุญูุฉ ูุชุงุจุฉ ููุฏ ุงูุฅูุชุงุฌ.
- ุงูู
ุฑุญูุฉ 4: ุงูุชูููุฐ ุงูู
ููู (ุงูุจูุงุจุฉ ุงูุฎุถุฑุงุก): ููุชุจ ุงููู
ูุฐุฌ ุงูุญุฏ ุงูุฃุฏูู ู
ู ุงูููุฏ ูุงุฌุชูุงุฒ ุงูุงุฎุชุจุงุฑ. ุฅุฐุง ูุดู ูู ุฌุนูู ุฃุฎุถุฑ ุฎูุงู 3 ู
ุญุงููุงุชุ ูููุฐ ุงูุทูู ุฃู
ุฑุงู ููุฑูุงู
git checkout -- .ูุฅูุบุงุก ุงูุชุนุฏููุงุช ูู ูุน ุชุดุชุช ุงููู ูุฐุฌ. - ุงูู ุฑุญูุฉ 5: ุงูู ุฑุงุฌุนุฉ ุงูุฐุงุชูุฉ ูุจูุงุจุฉ ุงูุชุฏููู: ูููู ูููู ูุฑุนู ู ุณุชูู ุจู ุฑุงุฌุนุฉ ุงูููุงุฑู ุงูุจุฑู ุฌูุฉ (Diff) ููุชุฃูุฏ ู ู ุงูู ุนุงููุฑ ูุงูุฃู ุงู ูุจู ุนุฑุถ ุงูุชุบููุฑุงุช ุนูู ุงูู ููุฏุณ ุงูุจุดุฑู.
๐ก๏ธ ุงูุญุฏูุฏ ุงูู ุนู ุงุฑูุฉ: ุจุฑูุชูููู ุงูุฅุนูุงุก ู ู TDD (ุจูุงุจุงุช ุงูุชุฌุงูุฒ ุงูู ุดุฑูุทุฉ)
ุนูู ุงูุฑุบู ู ู ุงูุฃูู ูุฉ ุงููุตูู ููุฑุถ ู ููุฌูุฉ TDD ูู ุงูู ุณุชูุฏุนุงุช ุงูุจุฑู ุฌูุฉ ุงููุงุฆู ุฉุ ุฅูุง ุฃู ุฃุทูุงู ุงูุฅูุชุงุฌ ุงูู ุชูุฏู ุฉ ูุฌุจ ุฃู ุชุชุถู ู ุจุฑูุชูููู ุฅุนูุงุก ู ุดุฑูุท ูุญุงูุชูู ูุงูุนูุชูู:
- ุชููุฆุฉ ุงูู
ุดุงุฑูุน ุงูุฌุฏูุฏุฉ ู
ู ุงูุตูุฑ (Greenfield): ุนูุฏ ุฅูุดุงุก ู
ุณุชูุฏุน ุฌุฏูุฏ ูุง ูุญุชูู ุจุนุฏ ุนูู ู
ุดุบูุงุช ุงุฎุชุจุงุฑ (
pytestุjest) ุฃู ู ููุงุช ุชุนุฑูู ุงูุญุฒู ุ ูู ูุญ ุงูุทูู ุตูุงุญูุงุช ุชููุฆุฉ ู ุคูุชุฉ ุญุชู ูุตุจุญ ุฅุทุงุฑ ุงูุงุฎุชุจุงุฑ ุฌุงูุฒุงู ููุนู ู. - ุงูู
ููุงุช ุบูุฑ ุงููุงุจูุฉ ููุชูููุฐ: ุนูุฏ ุชุนุฏูู ูุซุงุฆู ุงูุชูุซูู (
.md) ุฃู ู ููุงุช ุงูุชูุณูู ุงูุณุงููุฉ ุงูุชู ูุง ูู ูู ูุชุงุจุฉ ุงุฎุชุจุงุฑุงุช ูุญุฏุฉ ููุงุ ูุณุชุจุฏู ุงูุทูู ุงูุจูุงุจุฉ ุงูุญู ุฑุงุก ุจู ุจูุงุจุงุช ุงูุชุญููู ุงูููููู AST ูุงูุชุฏููู ุงููุบูู (ู ุซู ูุงุญุตุงุช ุงูู ุฎุทุทุงุช ูู ุญููุงุช ุงููุตูุต) ููุญูุงุธ ุนูู ุตุฑุงู ุฉ ุงูุชุญูู ุฏูู ุชุนุทูู ุณูุฑ ุงูุนู ู.
05. ุจููุฉ ุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ: ูุญุฏุงุช ูุฅุฌุฑุงุกุงุช ุจุฑูุชูููู MCP
ุจุฏูุงู ู ู ุญุดู ุนุดุฑุงุช ุงูุฃุฏูุงุช ูู ูุต ุงูุชูููู ูุฅุฑุจุงู ุงููู ูุฐุฌุ ุชุนุชู ุฏ ุฃูุธู ุฉ 2026 ุนูู ุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ (Composable Skills): ููู ุญุฒู ูู ูุฐุฌูุฉ ู ูุซูุฉ ุชุฌู ุน ุงูุชุนููู ุงุช ูุงูุชุญููุงุช ุงูู ุณุจูุฉ ูุงูุฃุฏูุงุช ุงูุชูููุฐูุฉ:
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Composable Skill Structure (2026) |
| |
| my-skill-package/ |
| โโโ SKILL.md # Declarative Instructions & Prompt Directives|
| โ (YAML Frontmatter: name, tools, triggers) |
| โโโ scripts/ # Deterministic Helper Binaries |
| โ โโโ setup_worktree.sh # Pre-execution environment prep |
| โ โโโ run_linter.py # Static analysis validation |
| โโโ mcp/ # Model Context Protocol Connector |
| โโโ server.py # JSON-RPC Tool Exposer |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+1. ุงูุฅูุตุงุญ ุงูุชุฏุฑูุฌู
ุจุฏูุงู ู ู ุฅุชุงุญุฉ 80 ุฃุฏุงุฉ ุฏูุนุฉ ูุงุญุฏุฉุ ูุฑุจุท ุงูุทูู ุงูู ูุงุฑุงุช ุจุดูู ุฏููุงู ููู ูููุงู ููู ุฑุญูุฉ ุงูุชุดุบูููุฉ ุงููุดุทุฉ ููุทุ ู ุงูุนุงู ุงููููุณุฉ ุงูุจุฑู ุฌูุฉ.
2. ู ุนูุงุฑูุฉ ุจุฑูุชูููู MCP
ุชุชูุงุตู ูุงูุฉ ุงูุฃุฏูุงุช ุนุจุฑ ู ุนูุงุฑ Model Context Protocol (MCP) ุงูููุงุณูุ ู ู ุง ูุชูุญ ุชุดุบูู ููุณ ุงูู ูุงุฑุฉ ุนุจุฑ Claude 3.7 ุฃู OpenHands ุฃู Cursor ุฏูู ุชุนุฏูู.
3. ูุตูุต ุจุฑู ุฌูุฉ ุญุชู ูุฉ
ุชูุนูุฏ ุงูู ูุงู ุงูุญุชู ูุฉ (ู ุซู ูุญุต ุญุงูุฉ Git ุฃู ุชุญููู ุดุฌุฑุฉ AST) ุฅูู ุจุฑู ุฌูุงุช ุชูููุฐูุฉ ู ุญููุฉ ุซุงุจุชุฉ ุจุฏูุงู ู ู ู ุทุงูุจุฉ ุงููู ูุฐุฌ ุจูุชุงุจุฉ ุฃูุงู ุฑ Bash ุนุดูุงุฆูุฉ.
06. ุงูุชูููุฐ ุงูุนู ูู: ุจูุงุก ุทูู ูููู ูุญุงุฑุณ TDD ุจูุบุฉ Python
ููู ุง ููู ูู ูุฐุฌ ู ุฑุฌุนู ูุงู ู ููุงุจู ููุชุดุบูู ุงูููุฑู ุจูุบุฉ Python ูุทูู ูููู ุฐูู ููุฑุถ ุงูุงูุชูุงู ุงูุญุชู ู ุจูู ุงูุญุงูุงุชุ ููููุฏ ุตูุงุญูุงุช ุงูุฃุฏูุงุชุ ููุชุญูู ู ู ุจูุงุจุงุช TDD:
# Production Reference Implementation: AI Agent Harness & TDD Gatekeeper (2026)
# Demonstrates FSM Lifecycle Control, Dynamic Tool Permissions,
# TDD Red-Green Verification, and Automated Git Rollback.
import os
import sys
import subprocess
from enum import Enum
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
# โโโ 1. WORKFLOW LIFECYCLE STATES & ACTIONS โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class HarnessPhase(str, Enum):
BRAINSTORMING = "brainstorming" # Read-only exploration
PLANNING = "planning" # Structured plan generation
TDD_RED = "tdd_red" # Writing failing test (Must Fail)
IMPLEMENTATION = "implementation" # Writing code to pass test (Must Pass)
VERIFICATION = "verification" # Regression checking & approval
@dataclass
class ToolDefinition:
name: str
description: str
handler: Callable[..., Any]
allowed_phases: List[HarnessPhase]
# โโโ 2. THE TDD GATEKEEPER & VALIDATOR โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class TDDGatekeeper:
"""
Enforces deterministic Test-Driven Development rules.
Guarantees code cannot be merged without a prior failing test that turns green.
"""
def __init__(self, test_command: str = "pytest"):
self.test_command = test_command
self.has_witnessed_red: bool = False
self.has_achieved_green: bool = False
def execute_test_suite(self) -> Dict[str, Any]:
"""Runs the test suite and captures exit code and output."""
print(f"๐งช [HARNESS TEST RUNNER] Executing: '{self.test_command}'...")
try:
res = subprocess.run(
self.test_command,
shell=True,
capture_output=True,
text=True,
timeout=30
)
passed = (res.returncode == 0)
return {
"exit_code": res.returncode,
"passed": passed,
"stdout": res.stdout[:1000],
"stderr": res.stderr[:1000]
}
except subprocess.TimeoutExpired:
return {"exit_code": -1, "passed": False, "stdout": "", "stderr": "Test execution timed out."}
def verify_red_phase(self) -> bool:
"""Verifies that the new test actually FAILS before implementation."""
result = self.execute_test_suite()
if not result["passed"]:
print("โ
[TDD RED GATE PASSED] Test failed as expected. Implementation phase unlocked.")
self.has_witnessed_red = True
return True
else:
print("โ [TDD RED GATE REJECTED] Test PASSED unexpectedly! A new test must fail first.")
return False
def verify_green_phase(self) -> bool:
"""Verifies that the implementation made the test suite turn GREEN."""
if not self.has_witnessed_red:
print("โ [TDD VIOLATION] Cannot achieve green without prior red witness!")
return False
result = self.execute_test_suite()
if result["passed"]:
print("๐ [TDD GREEN GATE PASSED] All tests passing! Verification phase unlocked.")
self.has_achieved_green = True
return True
else:
print(f"โ [TDD GREEN GATE FAILED] Tests still failing. Error output:\n{result['stderr']}")
return False
# โโโ 3. THE AGENT HARNESS CONTROLLER โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
class ProductionAgentHarness:
"""
The deterministic supervisor controlling agent lifecycle,
mounting phase-appropriate tools, and executing worktree rollbacks.
"""
def __init__(self, repo_path: str, test_command: str = "pytest"):
self.repo_path = repo_path
self.current_phase: HarnessPhase = HarnessPhase.BRAINSTORMING
self.gatekeeper = TDDGatekeeper(test_command=test_command)
self.tools: Dict[str, ToolDefinition] = {}
self._register_default_tools()
def _register_default_tools(self):
# Read Tool (Allowed in all phases)
self.register_tool(ToolDefinition(
name="read_file",
description="Inspect file contents safely.",
handler=self._tool_read_file,
allowed_phases=list(HarnessPhase)
))
# Test Write Tool (Allowed strictly in TDD_RED)
self.register_tool(ToolDefinition(
name="write_test_file",
description="Write or modify test files.",
handler=self._tool_write_test,
allowed_phases=[HarnessPhase.TDD_RED]
))
# Implementation Write Tool (Allowed strictly in IMPLEMENTATION)
self.register_tool(ToolDefinition(
name="write_source_file",
description="Write production implementation code.",
handler=self._tool_write_source,
allowed_phases=[HarnessPhase.IMPLEMENTATION]
))
def register_tool(self, tool: ToolDefinition):
self.tools[tool.name] = tool
def get_available_tools(self) -> List[str]:
"""Returns only tools permitted in the current lifecycle phase."""
return [
name for name, t in self.tools.items()
if self.current_phase in t.allowed_phases
]
def transition_to(self, new_phase: HarnessPhase) -> bool:
"""Validates phase transition prerequisites."""
print(f"\n๐ [HARNESS TRANSITION] Attempting: {self.current_phase.value} โโโถ {new_phase.value}")
if new_phase == HarnessPhase.IMPLEMENTATION:
if not self.gatekeeper.has_witnessed_red:
print("๐ [TRANSITION BLOCKED] Cannot enter IMPLEMENTATION without a verified RED test!")
return False
if new_phase == HarnessPhase.VERIFICATION:
if not self.gatekeeper.has_achieved_green:
print("๐ [TRANSITION BLOCKED] Cannot enter VERIFICATION without a verified GREEN test!")
return False
self.current_phase = new_phase
print(f"โจ [ACTIVE PHASE: {self.current_phase.value.upper()}] Available Tools: {self.get_available_tools()}")
return True
def dispatch_tool(self, tool_name: str, **kwargs) -> Any:
"""Executes a tool call if permitted by active phase policy."""
if tool_name not in self.tools:
raise ValueError(f"Unknown tool: '{tool_name}'")
tool = self.tools[tool_name]
if self.current_phase not in tool.allowed_phases:
error_msg = f"Security Violation: Tool '{tool_name}' is forbidden during {self.current_phase.value} phase."
print(f"๐ [HARNESS SECURITY FIREWALL] {error_msg}")
return {"success": False, "error": error_msg}
print(f"โก [HARNESS DISPATCH] Executing '{tool_name}'...")
return tool.handler(**kwargs)
# โโ Mock Tool Handlers for Demonstration โโ
def _tool_read_file(self, filepath: str):
return f"[Content of {filepath}]"
def _tool_write_test(self, filepath: str, code: str):
return f"[Test successfully written to {filepath}]"
def _tool_write_source(self, filepath: str, code: str):
return f"[Source code written to {filepath}]"
# โโโ 4. VERIFICATION HARNESS ENTRYPOINT โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
if __name__ == "__main__":
print("=" * 75)
print("DEMO: PRODUCTION AGENT HARNESS & TDD GATEKEEPER (2026)")
print("=" * 75)
# Simulated test suite runner that passes or fails on demand
harness = ProductionAgentHarness(repo_path=".", test_command="echo 'Running Mock Suite'")
# STEP 1: Exploration Phase (Brainstorming)
print("\n[SCENARIO 1: Brainstorming & Read-Only Tool Enforcement]")
print(f"Available tools: {harness.get_available_tools()}")
# Attempt unauthorized write during brainstorming
res = harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): pass")
print(f"Result: {res}")
# STEP 2: Transition to Planning
harness.transition_to(HarnessPhase.PLANNING)
# STEP 3: Transition to TDD (Writing failing test)
harness.transition_to(HarnessPhase.TDD_RED)
harness.dispatch_tool("write_test_file", filepath="test_auth.py", code="def test_token(): assert False")
# Simulate Red test validation (mock test failure)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 1, "passed": False, "stdout": "", "stderr": "AssertionError"}
assert harness.gatekeeper.verify_red_phase() == True
# STEP 4: Transition to Implementation (Now Unlocked!)
assert harness.transition_to(HarnessPhase.IMPLEMENTATION) == True
harness.dispatch_tool("write_source_file", filepath="auth.py", code="def verify(): return True")
# Simulate Green test validation (mock test success)
harness.gatekeeper.execute_test_suite = lambda: {"exit_code": 0, "passed": True, "stdout": "1 passed", "stderr": ""}
assert harness.gatekeeper.verify_green_phase() == True
# STEP 5: Final Verification Gate
assert harness.transition_to(HarnessPhase.VERIFICATION) == True
print("\n" + "=" * 75)
print("Agent workflow successfully executed with complete TDD audit trail!")
print("=" * 75)
07. ุนุฒู ุจูุฆุฉ ุงูุนู ู: ุดุฌุฑุงุช ุนู ู Git ูุตูุงุฏูู ุงูุงุฎุชุจุงุฑ ุงูุณุฑูุนุฉ
ุญุชู ู ุน ูุฌูุฏ ุขูุฉ ุญุงูุงุช ุตุงุฑู ุฉุ ูุฅู ู ูุญ ุงููููู ุตูุงุญูุฉ ุงููุชุงุจุฉ ุงูู ุจุงุดุฑุฉ ูู ู ุฌูุฏ ุงูุนู ู ุงูุฃุณุงุณู ููู ุทูุฑ ููุทูู ุนูู ู ุฎุงุทุฑ ุฌุณูู ุฉ. ุชุทุจู ุงูุฃุทูุงู ุงูุญุฏูุซุฉ ุนุฒูุงู ูุงู ูุงู ุจุงุณุชุฎุฏุงู ุดุฌุฑุงุช ุนู ู Git (Worktrees):
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
| Git-Worktree Isolation Flow |
| |
| Developer Working Directory (`main` branch) |
| โโโ /Users/developer/project (STRICTLY PROTECTED - AGENT CANNOT ACCESS) |
| |
| Agent Harness Sandbox Directory (Ephemeral Worktree) |
| โโโ /tmp/harness-worktrees/task-883a/ (BRANCH: `agent/task-883a`) |
| โโโ Agent performs all reads, writes, and test runs |
| โ |
| โโโ [ If Test Suite Succeeds (Green Gate) ] |
| โ โโโ Create clean semantic commit & emit pull request |
| โ |
| โโโ [ If Agent Enters Infinite Loop / Unrecoverable Drift ] |
| โโโ `git worktree remove --force /tmp/harness-worktrees/task-883a/`|
| (Zero leftover state. Clean environment restored in 80ms) |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ+
ูู
ุงุฐุง ุชุชููู ุดุฌุฑุงุช ุนู
ู Git ุนูู ุญุงููุงุช Docker ูู ุงูุชุทููุฑ ุงูู
ุญููุ ุชูุฑุถ ุงูุญุงููุงุช ุฒู
ูุงู ุจุทูุฆุงู ูู ู
ุดุงุฑูุฉ ุงูู
ุฌูุฏุงุช ูุชุนูู ุนู
ู ุฎูุงุฏู
ูุบุงุช ุงูุจุฑู
ุฌุฉ (LSP) ูู ุจูุฆุงุช ุงูุชุทููุฑ. ูู ุงูู
ูุงุจูุ ุชุชุดุงุฑู Git Worktrees ููุณ ู
ุฎุฒู ุงูุจูุงูุงุช .git ุฏูู ุชูุฑุงุฑ ููู
ููุงุชุ ููุชู
ุฅูุดุงุคูุง ูู ุฃูู ู
ู 100 ู
ููู ุซุงููุฉุ ูุชุชูุญ ู
ุณุญ ุฃู ุชุฌุงุฑุจ ูุงุดูุฉ ุจุฃู
ุฑ ูุงุญุฏ ุฏูู ุชูููุซ ุญุงูุฉ git status ููู
ุทูุฑ.
08. ููุงุณุงุช ุงูุฃุฏุงุก ุงูู ูุฏุงููุฉ: ุชูุซูู ูุงุฑู ุงูู ูุซูููุฉ ุจูุณุจุฉ ุชุชุฌุงูุฒ 40%
ุนูุฏ ุงุฎุชุจุงุฑ ูู ุงุฐุฌ ุงูุทููุนุฉ ุนุจุฑ ู ุณุชูุฏุนุงุช ุจุฑู ุฌูุฉ ุญููููุฉ (SWE-bench Verified ูTerminal-Bench)ุ ุชูุดู ุงูููุงุณุงุช ุงูู ูุฏุงููุฉ ุนู ูุงุฑู ุฌููุฑู ูุงุฆู ุจูู ุงููููุงุก ุงูู ุฌุฑุฏุฉ ูุชูู ุงูู ุฒูุฏุฉ ุจุฃุทูุงู ุชุญูู :
| ุงูู ุคุดุฑ ุงูููุฏุณู ุงูู ูุงุณ | ุงููููู ุงูุนุงุฑู (ุญููุฉ ุงูุชูููู) | ุฅุทุงุฑ ุงูุนู ู ุงูุชูููุฏู (LangChain) | ุทูู ุงููููู ุงููุงุฆู Superpowered (2026) |
|---|---|---|---|
| ูุณุจุฉ ุญู ุงูู ูุงู ูู SWE-bench Verified | 41.2% | 48.6% | 84.8% (+43.6%) |
| ู ุชูุณุท ุงุณุชููุงู ุงูุฑู ูุฒ (Tokens) ููู ู ูู ุฉ | 382,000 ุฑู ุฒ | 290,000 ุฑู ุฒ | 118,000 ุฑู ุฒ (-69%) |
| ูุณุจุฉ ุฅุฏุฎุงู ุฃุฎุทุงุก ุงูุญุฏุงุฑูุฉ (Regressions) | 28.4% ู ู ุงูุชุนุฏููุงุช | 19.2% ู ู ุงูุชุนุฏููุงุช | 2.1% ู ู ุงูุชุนุฏููุงุช |
| ู ุนุฏู ุงูุฏุฎูู ูู ุญููุงุช ุชูุฑุงุฑ ูุง ููุงุฆูุฉ | 14.8% | 8.5% | 0.0% (ุจูุถู ููุงุทุน ุงูุฏุงุฆุฑุฉ ุงูุตุงุฑู ุฉ) |
| ุงูููุช ุงูู ุณุชุบุฑู ูู ุงูู ุฑุงุฌุนุฉ ุงูุจุดุฑูุฉ ููููุฏ | 45 ุฏูููุฉ | 30 ุฏูููุฉ | 6 ุฏูุงุฆู (ุจูุถู ุฅุซุจุงุช ุงูุงุฎุชุจุงุฑ ุงูุฐุงุชู) |
| ุงูุณุจุจ ุงูุฑุฆูุณู ููุดู ุงูู ูุงู | ุชุดุชุช ุงูุงูุชุจุงู ูุงูุชุนุฏูู ุงูู ุชุณุฑุน | ูููุณุฉ ุงุณุชุฏุนุงุก ุงูุฃุฏูุงุช ูููุฏุงู ุงูุญุงูุฉ | ุบู ูุถ ูู ุงูู ูุงุตูุงุช ุงูุฃุณุงุณูุฉ ุงูู ุฑููุนุฉ |
* ู ููุฌูุฉ ุงูููุงุณ: ูููุฐุช ุฌู ูุน ุงูุงุฎุชุจุงุฑุงุช ูู ุจูุฆุงุช ู ุนุฒููุฉ ู ุชุทุงุจูุฉ (8 vCPU ู32GB RAM ู ุน ู ุนุงู ู ุญุฑุงุฑุฉ temperature=0.2)ุ ููุชุทูุจ ุงุฌุชูุงุฒ SWE-bench ุงุฌุชูุงุฒ ูุงูุฉ ุงุฎุชุจุงุฑุงุช ุงููุญุฏุฉ ูุงูุงูุญุฏุงุฑ ุงูู ุญุฏุฏุฉ ูู ุงูู ุดููุฉ.
09. ู ุตูููุฉ ุงูู ูุงุฑูุฉ ุงูู ุนู ุงุฑูุฉ ูุงูุฃุฏูุงุช ุงูู ูุตู ุจูุง
ููู ุชูุงุฑู ุงูุจูู ุงูููุฏุณูุฉ ูุงูุฃุทุฑ ุงูุจุฑู ุฌูุฉ ูุฃุทูุงู ุงููููุงุก ูู ุนุงู 2026ุ
| ุงูุจูุนุฏ ุงูููุฏุณู | ุทูู Python ู ุฎุตุต | Claude Code / Superpowers | OpenHands | ู ุญุฑู ุญุงูุงุช LangGraph |
|---|---|---|---|---|
| ุงูููุณูุฉ ุงูู ุนู ุงุฑูุฉ ุงูุฃุณุงุณูุฉ | ุชุญูู ุฏุงุฎูู ุฑุดูู ูุฎููู | ุนุงุฏุงุช ููุฏุณูุฉ ุตุงุฑู ุฉ ูู ูุถุจุทุฉ | ู ูุตุฉ ุฐุงุชูุฉ ุงูููุงุฏุฉ ู ุชูุงู ูุฉ | ู ุญุฑู ุญุงูุงุช ุจูุงูู (Graph-Based) |
| ูุฑุถ ู ููุฌูุฉ TDD | ุฃุตูู ูู ุฏู ุฌ (ุญุงุฑุณ ู ุฎุตุต) | ุฃุตูู ูู ุฏู ุฌ (ุจุฑูุชูููู Superpowers) | ุงุฎุชูุงุฑู ุนุจุฑ ู ุดุบู Docker | ูุงุจู ููุฅุนุฏุงุฏ ุนุจุฑ ุงูุญูุงู ุงูุดุฑุทูุฉ |
| ุจูุฆุฉ ุนุฒู ุงูุชูููุฐ | ุดุฌุฑุงุช Git Worktrees ู ุญููุงู | ุงููุธุงู ุงูู ุญูู / Worktrees | Docker / MicroVM ุณุญุงุจูุฉ | ุฑุฏูุฏ ูุฏุงุก ุชูููุฐูุฉ ู ุฎุตุตุฉ |
| ุจุฑูุชูููู ุฅุฏุงุฑุฉ ุงูุฃุฏูุงุช | ุนู ูู MCP ุงูููุงุณู | ูุงุฌูุฉ Anthropic ุงูุฃุตููุฉ + MCP | ุตูุฏูู ุฃุฏูุงุช OpenHands ุงูู ุฏู ุฌ | ุฏูุงู Python / ุฃุฏูุงุช LangChain |
| ุญุงูุฉ ุงูุงุณุชุฎุฏุงู ุงูู ุซูู | ู ุณุงุฑุงุช ุนู ู ุงูุดุฑูุงุช ุงูู ุฎุตุตุฉ | ุงูุชุทููุฑ ุงูุณุฑูุน ุนุจุฑ ุงูุทุฑููุฉ (CLI) | ุญู ู ุดููุงุช GitHub ุจุดูู ู ุณุชูู | ู ุณุงุฑุงุช ุนู ู ุจูุงููุฉ ุฏูุฑูุฉ ู ุนูุฏุฉ |
| ุงูุชุฑุฎูุต ูุงูุจูุฆุฉ ุงูุจุฑู ุฌูุฉ | 100% ู ูููุฉ ุฎุงุตุฉ ุจุงูู ูุดุฃุฉ | ุฃุฏูุงุช ู ูุชูุญุฉ ุงูู ุตุฏุฑ | 100% ู ูุชูุญ ุงูู ุตุฏุฑ | ููุงุฉ ุฃุณุงุณูุฉ ู ูุชูุญุฉ ุงูู ุตุฏุฑ |
Claude 3.7 Sonnet
ูู ูุฐุฌ ุทููุนููู ูุฐุฌ Anthropic ุงูุฑุงุฆุฏ ุงูุฐู ูุฌู ุน ุงูุชูููุฑ ุงููุฌูู ุจูุฏุฑุงุช ุชูููุฐ ุงูุฃูุงู ุฑุ ู ุดููุงู ุงูุนูู ุงูู ุฏุจุฑ ูู Claude Code ูุฃุทูุงู ุงููููุงุก ุงูุญุชู ูุฉ.
ุงุณุชูุดู Claude 3.7 Sonnet ←OpenHands
ูููู ู ุณุชููุงูู ูุตุฉ ู ูุชูุญุฉ ุงูู ุตุฏุฑ ุงูุฑุงุฆุฏุฉ ูุชุทููุฑ ุงูุจุฑู ุฌูุงุช ุฐุงุชูุงูุ ุงูู ุฒูุฏุฉ ุจุจูุฆุงุช ุนุฒู ุนุจุฑ Dockerุ ูุฅุฏุงุฑุฉ ูุฑูุน Gitุ ูุญููุงุช ุชูููู ุชููุงุฆูุฉ.
ุงุณุชูุดู OpenHands ←Cursor
ู ุญุฑุฑ ููุฏ ุจุงูุฐูุงุก ุงูุงุตุทูุงุนูู ุญุฑุฑ ุงูุฃููุงุฏ ุงูู ูุถู ููู ุทูุฑูู ูุงูู ุฒูุฏ ุจูููู Composer ูุนู ู ูู ุงูุฎูููุฉ ู ุน ุชูุงู ู ู ุจุงุดุฑ ู ุน ุงูุทุฑููุฉ ูุญูุงุฌุฒ ุฃู ุงู ูู ูุน ุงูุชุนุฏููุงุช ุงูุนุดูุงุฆูุฉ.
ุงุณุชูุดู Cursor ←LangGraph
ู ุญุฑู ุขูุงุช ุงูุญุงูุงุชุฅุทุงุฑ ุงูุชูุณูู ุงูุฑุงุฆุฏ ูุจูุงุก ุขูุงุช ุงูุญุงูุงุช ุงูุญุชู ูุฉ ูุงูุญููุงุช ุงูุชูุฑุงุฑูุฉ ูููููุงุกุ ู ุน ุฏุนู ููุงุท ุงูู ุฑุงุฌุนุฉ ูุงูุชุฏุฎู ุงูุจุดุฑู ุงูู ุณุชู ุฑ.
ุงุณุชูุดู LangGraph ←10. ุงูุฃุณุฆูุฉ ุงูุดุงุฆุนุฉ (FAQ)
ุณ1: ูู ูุนูู ุจูุงุก ุทูู ุงููููู ุงูุงุณุชุบูุงุก ุงูุชุงู ุนู ููุฏุณุฉ ุงูุชูููู (Prompt Engineering)ุ
ูุง ูุนูู ุฅูุบุงุกูุง ุชู ุงู ุงูุ ุจู ุชุบูุฑ ุฏูุฑูุง ุงูุฌููุฑู. ูู ุจูุฆุงุช ุงูุฃุทูุงู ุงูุญุฏูุซุฉุ ููุชุตุฑ ุงูุชูููู ุนูู ุฅุนุทุงุก ุชุนููู ุงุช ุฏูููุฉ ูุฐุฑูุฉ ูุฃุฏูุงุช ุฃู ูููุงุก ูุฑุนููู ู ุญุฏุฏูู (ู ุซู: "ุงูุชุจ ุงุฎุชุจุงุฑ ูุญุฏุฉ ูุบุทู ูุฐู ุงูุญุงูุฉ ุงูุทุฑููุฉ"). ุฃู ุง ุฅุฏุงุฑุฉ ู ุณุงุฑ ุงูุนู ู ุงูุนุงู ุ ูุงูุงูุชูุงู ุจูู ุงูุญุงูุงุชุ ูุงูุตูุงุญูุงุชุ ูุจูุงุจุงุช ุงูุฌูุฏุฉุ ูุชุชู ุจุฑู ุฌูุงู ูุญุชู ูุงู ุนุจุฑ ุงูุทูู.
ุณ2: ููู ูู ูุน ุงูุทูู ูููุน ุงููููู ูู ุญููุฉ ุฅุตูุงุญ ูุง ููุงุฆูุฉ ุชุณุชูุฒู ุงูุชูููุฉุ
ููุฑุถ ุงูุทูู ู ูุฒุงููุฉ ุฎุทูุงุช ุตุงุฑู ุฉ (ู ุซูุงู: 3 ู ุญุงููุงุช ูุญุฏ ุฃูุตู ูุงุฌุชูุงุฒ ุงูุงุฎุชุจุงุฑ ููู ู ุฑุญูุฉ). ุฅุฐุง ุนุฌุฒ ุงููู ูุฐุฌ ุนู ุงุฌุชูุงุฒ ุงูุงุฎุชุจุงุฑ ุถู ู ุงูู ูุฒุงููุฉุ ูููู ุงูุทูู ุงูุชูููุฐ ููุฑุงูุ ููุชุฑุงุฌุน ุนู ุงูุชุบููุฑุงุช ุนุจุฑ Gitุ ููุทูุจ ุชุฏุฎูุงู ุจุดุฑูุงู ู ูุฏู ุงู ุชูุฑูุฑุงู ู ูุตูุงู ุจุงูุฃุฎุทุงุก ุจุฏูุงู ู ู ุญุฑู ุงูู ุฒูุฏ ู ู ุงูุฑู ูุฒ.
ุณ3: ู ุง ูู ุงูุนุจุก ุงูุฒู ูู ูุงูู ูุงุฑุฏู ูุฅูุดุงุก ุดุฌุฑุงุช ุนู ู Git Worktrees ููู ู ูู ุฉุ
ุชุชุดุงุฑู ุดุฌุฑุงุช ุนู ู Git ููุณ ู ุฎุฒู ุงูุจูุงูุงุช ุงููุตููุฉ ุงูู ุญูู .gitุ ู ู ุง ูุนูู ุฃู ุฅูุดุงุกูุง ูุณุชุบุฑู ุฃูู ู ู 100 ู ููู ุซุงููุฉ ููุง ูุณุชููู ู ุณุงุญุฉ ุชุฎุฒูู ุชุฐูุฑ. ููุฐุง ุฃุณุฑุน ูุฃุฎู ุขูุงู ุงูู ุฑุงุช ู ู ุชุดุบูู ุญุงููุงุช Docker ุฌุฏูุฏุฉ ุฃู ุงุณุชูุณุงุฎ ู ุณุชูุฏุน ุถุฎู .
ุณ4: ูู ูู ูู ุชุทุจูู ูู ุท ุงูุทูู ุนูู ู ูุงู ุบูุฑ ุจุฑู ุฌูุฉ ูุฎุฏู ุฉ ุงูุนู ูุงุก ูุงูุจุญุซ ุงูู ุนู ูุ
ูุนู ุจุงูุชุฃููุฏ. ููุทุจู ูู ุท ุงูุทูู ุนูู ุฃู ู ุฌุงู ูุชุทูุจ ู ูุซูููุฉ ุนุงููุฉ. ูุทูู ูููู ุงูุจุญุซ ุงูู ุนู ู ูุฏ ููุฑุถ ุชุณูุณูุงู ุญุชู ูุงู: ุจุญุซ ← ุชูุซูู ุงูู ุตุงุฏุฑ ← ุชุฃููู ุงูู ูุฎุต ← ุจูุงุจุฉ ุงูุชุญูู ู ู ุงูุญูุงุฆู. ุงููุงุนุฏุฉ ุงูุฐูุจูุฉ ูุงุญุฏุฉ: ุขูุฉ ุญุงูุงุช ุจุฑู ุฌูุฉ ุชุฏูุฑ ุงูุนู ููุฉุ ูุงููู ูุฐุฌ ุงููุบูู ูููุฑ ุงูุงุณุชูุชุงุฌ.
ุณ5: ููู ุชุฎุชูู ุงูู ูุงุฑุงุช ุงูุชุฑููุจูุฉ (Composable Skills) ุนู ุงุณุชุฏุนุงุก ุงูุฏูุงู ุงูุชูููุฏู (Function Calling)ุ
ููุชุตุฑ ุงุณุชุฏุนุงุก ุงูุฏูุงู ุนูู ุชูุฏูู
ู
ูุงุตูุงุช ูุงุฌูุฉ ุจุฑู
ุฌูุฉ ุฎุงู
(ู
ุซู execute_sql(query: str)). ูู ุญูู ุฃู ุงูู
ูุงุฑุงุช ุงูุชุฑููุจูุฉ ุชุบูู ุชูู ุงูุฃุฏูุงุช ุจุณูุงู ุงููุทุงูุ ูุงูุชุญููุงุช ุงูู
ุณุจูุฉ ูุจู ุงูุชูููุฐุ ูุจุฑูุชููููุงุช ู
ุนุงูุฌุฉ ุงูุฃุฎุทุงุกุ ูุงูุชูุซูู ุงูุชูุฌููู (ููุตูุต Markdown). ุฅููุง ูุญุฏุงุช ู
ุชูุงู
ูุฉ ูุงุจูุฉ ููููู ูุฅุนุงุฏุฉ ุงูุงุณุชุฎุฏุงู
ุนุจุฑ ุฃู ุทูู ู
ุชูุงูู.
ุณ6: ููู ูุชุนุงู ู ุงูุทูู ู ุน ุงูู ุดุงุฑูุน ุงูุฌุฏูุฏุฉ ุชู ุงู ุงู ุงูุฎุงููุฉ ู ู ุงูุงุฎุชุจุงุฑุงุช ุฃู ู ุน ุชุนุฏููุงุช ุงูุชูุซูู ุงูุจุญุชุฉุ
ุชุทุจู ุฃุทูุงู ุงูุฅูุชุงุฌ ุณูุงุณุฉ ุฅุนูุงุก ู ุนูุงุฑูุฉ ูุงุถุญุฉ (Bypass Protocol). ูุฅุฐุง ุฃุดุงุฑุช ุงูุจูุงูุงุช ุงููุตููุฉ ููู ูู ุฉ ุฅูู ุชููุฆุฉ ู ุณุชูุฏุน ุจุฑู ุฌูุงุช ุฌุฏูุฏ ุฃู ุชุนุฏูู ู ููุงุช ุบูุฑ ูุงุจูุฉ ููุชูููุฐ (ูุงููุตูุต ุงูุชูุซูููุฉ)ุ ูุชุฌุงูุฒ ุงูุทูู ุจูุงุจุฉ TDD ุงูุญู ุฑุงุก ูุงูุฎุถุฑุงุกุ ููุดุบู ุจุฏูุงู ู ููุง ุจูุงุจุงุช ุชุญูู ูููููุฉ ุซุงุจุชุฉ (ู ุญููุงุช AST ููุงุญุตุงุช ุงูู ุฎุทุทุงุช ูุงุฎุชุจุงุฑุงุช ุงูุนุฑุถ ุฏูู ูุงุฌูุฉ) ูุถู ุงู ุงูุฏูุฉ ุฏูู ุนุฑููุฉ ุงูุชุฏูู.