Before we build anything, here's an honest assessment of each component: what's shipping code, what's partially implemented, and what's still just GitHub issues.
FastAPI server, DID system, Constitution, Memory (encrypted), 7 LLM providers, Voice (5 STT/TTS providers), Filebase storage, Privacy modes, MultiAgent multi-agent
Strategic Memory, Morning Signal, Backlog Hygiene, GitHub scan, Agent Mesh Protocol, Scheduler (APScheduler), Talon Coordinator, Signal-Talon dispatch. Missing: Backlog Constitution
Autonomous issue claiming, code execution, PR opening. Installed as pip package. Codex backend hardening in progress
CLI, vision providers, reviewer engine, loop runner, reporter, GitHub integration all shipped (11/13 closed). Missing: CI hook, Mesh integration
Test suite, type safety, validation, cleanup done (10/21 closed). Core extraction (NarrationEngine, screenshot helpers, state persistence) still open
| Component | What Exists (Code) | Repo | Status |
|---|---|---|---|
| Sovereign Core |
kestrel_sovereign/server.py — FastAPI runtime kestrel_sovereign/inception_service.py — DID creation kestrel_sovereign/features/constitution.py — Constitutional enforcement kestrel_sovereign/features/memory/ — Encrypted recall + graph kestrel_sovereign/llm/provider_registry.py — 7 LLM adapters kestrel_sovereign/voice/ — 5 STT/TTS providers (Deepgram, ElevenLabs, Faster Whisper, OpenAI, Piper) kestrel_sovereign/storage/providers/filebase_provider.py — Decentralized storage kestrel_sovereign/features/privacy/ — 5 privacy levels (actively tested) multi_agent.toml — Multi-agent hosting (5 agents configured) |
kestrel-sovereign | Running |
| Claws (PM) |
features/strategic_memory/feature.py — STRATEGY.yaml load/write + signal_dispatch features/strategic_memory/morning_signal.py — Daily briefing generator features/strategic_memory/backlog_hygiene.py — Score/grade issues features/strategic_memory/github_integration.py — Repo scanning features/strategic_memory/session_log.py — GitHub activity + Talon PR tracking features/strategic_memory/talon_handoff.py — Signal-agnostic Talon dispatch features/peers/mesh.py — Agent Mesh Protocol (MeshMessage dataclass + JSON serialization) features/peers/feature.py — send_mesh_message, mesh_inbox, receive tools features/talon/coordinator.py — TalonCoordinatorFeature (claim/batch/status/pause/resume) kestrel_agent.py — Scheduler defaults (morning_signal 8am, signal_dispatch 8:05am) heartbeat.py — Periodic self-checks (basic asyncio) |
kestrel-sovereign | 95% |
| Talon (Dev) |
kestrel-talon — Standalone package (pip installed) Ticket claiming, code execution, PR submission |
kestrel-talon | Installed |
| Eye (QA) |
kestrel-eye — Standalone package (11/13 issues closed) CLI runner, config schema (Pydantic), Anthropic + OpenAI vision providers Reviewer engine, loop runner, report generator (JSON + Markdown) GitHub issue reporter (auto-file, update, close per iteration) eye-technical.toml + eye-spawn.toml — consumer configs in sovereign |
kestrel-eye | 85% done |
| Flight (PO) |
kestrel-flight — TypeScript library (10/21 issues closed) Test suite (Vitest), type safety, input validation, cleanup done tests/e2e/demo_*.cjs — Source Playwright scripts to extract from |
kestrel-flight | 50% done |
| Claw (SDK) |
Android SDK repo with Kotlin/Java client Phase 1 complete, dependency maintenance mode |
kestrel-claw | Phase 1 done |
multi_agent.toml already defines 5 agents (Kestrel, demo, gabi, jason, noel) on separate ports.
Each agent gets its own data directory and can load its own STRATEGY.yaml.
The Falconer model doesn't require building a new platform — it requires
connecting the birds to each other and to the MultiAgent.
Agent Mesh Protocol and Scheduler are now shipped. Claws is 95% done (only Backlog Constitution remains). Phase 2 Talon integration is 4/6 complete. The remaining work: finish Backlog Constitution, Eye CI/Mesh hooks, and extract Flight's core library.
| Gap | What It Is | Why It Matters | Size |
|---|---|---|---|
| Agent Mesh Protocol | Structured message format for bird-to-bird communication. Claws assigns work → Talon picks up → Eye reviews → Flight reports. | DONE (Mar 30) — MeshMessage dataclass, 5 message types, JSON serialization, /agent/mesh endpoints, 21 tests passing. | DONE |
| Eye CI + Mesh | GitHub Action to auto-trigger Eye on Talon PRs (kestrel-eye #16). Mesh integration so Eye listens for review-needed messages and reports back to Claws (sovereign #432). | Eye's core is built but isolated. CI hook + Mesh makes it autonomous. | MEDIUM |
| Flight NarrationEngine | Extract the narration, screenshot, and demo-act logic from tests/e2e/demo_*.cjs into standalone TypeScript library. Core extraction tickets (kestrel-flight #1-#6) are open. |
Narrated demos are the product's proof. Flight makes them reproducible and automated. Voice system now adds TTS for audio narration. | MEDIUM |
| Backlog Constitution | Rules engine that rejects/downgrades backlog items that violate the Constitution or are too vague for AI execution. | 73% of human bottleneck comes from vague items. This is the productivity lever. | SMALL |
| Falconer Onboarding | kestrel falconer setup CLI command (sovereign #433). Creates agent in MultiAgent, DID, STRATEGY.yaml, configures all 4 birds. |
Jim partnership requires this. Can't scale if every falconer needs manual setup. | MEDIUM |
| Unified Falconer Dashboard | All 4 birds' status per falconer (sovereign #434). Claws/Talon/Eye/Flight cards with real-time metrics. Org-wide view for enterprise. | The "cockpit" that makes Falconer tangible for CIOs. Human bottleneck % is the key metric. | MEDIUM |
| Scheduler Upgrade | Replace basic asyncio heartbeat with proper scheduler. Morning Signal at 8am, signal_dispatch at 8:05am. |
DONE (Mar 30) — APScheduler wired in kestrel_agent.py with configurable cron defaults. | DONE |
The birds have a natural build order. You can't review PRs (Eye) if there's no code (Talon), and you can't demo (Flight) if there's nothing to demo (Eye + Talon output).
Phase 1 (Claws Mesh + Scheduler) and Phase 2 (Talon Integration) were built in parallel on March 30. 6 commits shipped in one session. Eye and Flight are sequential — Eye's runner must exist before Flight can orchestrate visual validation. Eye development can start now that Talon produces PRs to review.
Five phases. Real deliverables, not milestones. Each phase produces a working capability that the falconers can use immediately.
The PM bird now autonomously manages the backlog, enforces quality, and hands off work to Talon. 62 tests passing.
features/peers/mesh.py!dispatch suggest mode shows top issue without executing. features/strategic_memory/talon_handoff.pyTalon is now integrated into the Falconer loop. TalonCoordinatorFeature provides mesh dispatch + CLI fallback. 6 commits pushed, all tests passing.
features/talon/coordinator.pysuggest mode (!dispatch suggest shows top issue without executing). _get_talon_coordinator() helper._is_talon_pr() (branch prefix + label detection) and _review_latency() (hours between PR created/merged). Talon Outcomes section in reports. 12 tests.Eye v1 is 85% built — CLI, vision providers, reviewer, reporter, GitHub integration all shipped. This phase connects Eye to the autonomous loop via CI and Agent Mesh.
Flight is 50% done — test suite, types, validation shipped. Now extract the core library from existing Playwright demo scripts. Voice system (5 STT/TTS providers) enables audio-narrated demos as a differentiator.
tests/e2e/demo_*.cjs into standalone TypeScript. npm install @kestrel/flight.Wire it all together. Every falconer has all 4 birds. The daily loop runs without human intervention.
kestrel falconer setup --name "Jim" --repos org/repo1,org/repo2. Creates agent in MultiAgent, generates DID, creates STRATEGY.yaml, configures all 4 birds.Each falconer has primary and secondary responsibilities based on their strengths.
| Risk | Impact | Likelihood | Mitigation |
|---|---|---|---|
| Agent Mesh Protocol over-engineering | Delays all bird-to-bird integration | MITIGATED | Resolved. Kept it simple: Python dataclass + JSON serialization. No gRPC, no Kafka. 21 tests. Shipped Mar 30. |
| Eye vision LLM cost | Claude Haiku per screenshot adds up at scale | MEDIUM | Use Haiku (cheapest) for CI runs. Only escalate to Sonnet for failures. Cache known-good baselines. |
| Flight TypeScript extraction complexity | Demo scripts are tightly coupled to test infrastructure | MEDIUM | Extract incrementally: NarrationEngine first, then screenshot manager, then act sequencer. |
| Jason bandwidth (Healthcare partner + Talon + Eye) | Healthcare partner deadline (Apr 2) may starve Talon/Eye work | HIGH | Healthcare partner first. Talon hardening can start after Apr 2. Eye Phase 3 starts after Talon stabilizes. |
| 3-person team spread across 7 repos | Context switching, no deep focus time | MEDIUM | Each person owns 2 repos max at a time. Claws prioritizes so humans don't have to triage. |
| Enterprise onboarding before product is stable | Jim tries it, hits bugs, loses confidence | LOW | Phase 5 (onboarding) comes last. Jim sees demos but doesn't self-serve until loop is proven. |
Based on current state and dependencies, here's the critical path for the first real deliverable: Claws assigns work to Talon through Agent Mesh.
This is the minimum viable Falconer loop. Claws runs Morning Signal, identifies the top issue, sends an Agent Mesh message to Talon, and Talon claims it, codes it, and opens a PR. No Eye review, no Flight reporting — just the PM → Developer handoff. Once this loop runs end-to-end for one falconer (Gabi), you have the proof point for everything else.
features/peers/mesh.pyPOST /agent/mesh and GET /agent/mesh/inbox endpoints + send_mesh_message, mesh_inbox, receive_mesh_message tools in PeersFeature.!dispatch suggest previews without executing.kestrel-talon claim auto-invoked._is_talon_pr() + _review_latency().All 6 steps completed on March 30, 2026. 6 commits pushed (f6c8d21..d9326c2). 62 tests passing. The Claws → Talon loop is operational. Next focus: Eye CI hook + Backlog Constitution.