MultiHead: 하나의 GPU를 전문 AI 에이전트 팀으로 전환(오픈 소스)

Make your coding agent team smarter with tools. MultiHead is an orchestration and knowledge layer that sits alongside your existing tools — Claude Code, Codex, local models, or custom agents — and gives them persistent memory, verified knowledge, and multi-agent coordination. You don't switch workflows. You enhance them. Before: agent runs → output → forgets everything After: agent runs → output verified → knowledge stored → next run starts smarter "I built a team of coding agents, and became a human copy & paste machine. Then I built MultiHead." — axsar Your coding agent (Claude Code, Codex, whatever) works normally. MultiHead adds three things: 1. Knowledge that persists across sessions. Before you edit a file, MultiHead briefs you on what's known — constraints, warnings, contradictions, history. After you work, it extracts what you learned and stores it for next time. 2. Verification across independent sources. Night Shift runs in the background, cross-checking what was said in conversations against what the code actually does, what git history shows, and what CI reports. Agreements become corroborated facts. Disagreements get flagged. 3. Multi-agent coordination. Multiple agents working in different repos can share knowledge through a common store. No copy-paste, no Slack messages — deposit a claim, other agents query it. MultiHead is not a replacement for your tools. It's a layer underneath them. Integration points: - Claude Code — MCP server provides 25+ tools. Knowledge hooks auto-inject briefings before file edits. - Any CLI agent — call multihead briefing ormultihead kb "topic" from any script or agent. - Python — from multihead.client import MultiHeadClient for programmatic access. - Background — Night Shift runs nightly, extracting and verifying knowledge while you sleep. You can also use MultiHead directly via the interactive shell (multihead shell ) or CLI commands — but that's optional. The primary value is what it adds to your existing workflow. Same input to two systems: Input: Analyze the authentication system Typical AI: The authentication system uses JWT tokens for user authentication. Tokens appear to expire after a set duration and are validated during requests. There is also a refresh mechanism to issue new tokens. The system seems standard and follows common patterns. Your agent + MultiHead: CONSTRAINTS (corroborated — don't violate): • JWT tokens use RS256 signing with 24h expiry Source: auth/token_manager.py:48 · Confidence: high • Token validation middleware runs on every /api/ route Source: auth/middleware.py:12 · Confidence: high WARNINGS (stale — verify before assuming): • Refresh token logic does not handle expiration edge cases Source: auth/refresh.py:72 · Confidence: medium CONTRADICTION: • Token expiry set to 24h in config, but 12h in validation logic Sources: config/auth.yaml:12 ↔ auth/validator.py:33 Recommendation: align validation logic with configuration Typical AI describes what it sees. With MultiHead, your agent extracts facts, verifies them across sources, and surfaces conflicts — and remembers all of it for next time. You work (code, conversations, decisions) ↓ Night Shift extracts knowledge from all channels ↓ Fusion cross-checks: code vs git vs conversation vs CI ↓ Knowledge store tracks verified truth ↓ Briefings feed it back when you (or your agent) edit files Each cycle makes the system more accurate. Your agent doesn't start from scratch — it starts from verified institutional knowledge. pip install -e . multihead init --auto Then use it from your existing agent, or try it directly: # Query what the system knows multihead kb "authentication" # Get a briefing before editing a file multihead briefing src/auth/jwt_handler.py # Deposit knowledge multihead deposit "JWT tokens expire in 24h" -k auth.jwt.expiry # Run the full knowledge pipeline multihead nightshift run --head openai-gpt41-nano --batch # Or use the interactive shell multihead shell Two agents on the same machine, different repos. They share knowledge through the store — no copy-paste. Agent A (temperature estimator) defines the API contract: multihead deposit \ "Temperature estimator exposes GET /api/v1/estimate?sensor_id=X — returns JSON {celsius: float, confidence: float, timestamp: iso8601}. Updated every 5s. Returns 404 if sensor_id unknown." \ -k temperature_estimator.api.contract \ -p agent-a Agent B (pressure cooker controller) queries before writing integration code: multihead kb "temperature estimator" Agent B now knows the contract and builds to it. Later, Agent A asks for a briefing: multihead briefing temperature-estimator CONSTRAINTS: • API contract: GET /api/v1/estimate?sensor_id=X → {celsius, confidence, timestamp} • Pressure cooker depends on this endpoint — polls every 10s • Safety-critical: confidence > Step 1.1 explore Read webhook handler code OK (2.1s) >> Step 1.2 explore Check git history for timeout bugs OK (1.8s) >> Step 2.1 edit Fix retry timeout from 5s to 30s OK (3.4s) >> S