Convergence

Structural analysis adapters for external agent orchestration systems.

The operon_ai.convergence package bridges 5 external agent frameworks (Swarms, DeerFlow, AnimaWorks, Ralph, A-Evolve) into Operon's structural analysis layer. All adapters operate on serializable dicts — no external dependencies.

Five-Layer Architecture

┌─────────────────────────────────────────────┐
│  A-Evolve (evolution layer)                 │
├─────────────────────────────────────────────┤
│  AnimaWorks (cognitive layer)               │
├─────────────────────────────────────────────┤
│  AsyncThink (thinking layer)                │
├─────────────────────────────────────────────┤
│  Ralph / DeerFlow / Swarms (orchestration)  │
├─────────────────────────────────────────────┤
│  Operon (structural layer)                  │
└─────────────────────────────────────────────┘

Phase C1 — Foundation Adapters

Type-level bridges to Swarms, DeerFlow, AnimaWorks, Ralph, and A-Evolve. All produce ExternalTopology, consumed by analyze_external_topology() to apply Operon's four epistemic theorems as a structural linter.

• parse_swarm_topology() — Swarms workflow patterns
• parse_animaworks_org() — AnimaWorks org hierarchies
• parse_deerflow_session() — DeerFlow session configs
• parse_ralph_config() — Ralph hat definitions
• parse_aevolve_workspace() — A-Evolve workspace manifests

Phase C2 — Template Exchange

Seed Operon's PatternLibrary from external catalogs:

• seed_library_from_swarms() — 10 built-in Swarms patterns
• seed_library_from_deerflow() — DeerFlow sessions
• seed_library_from_acg_survey() — 8 ACG survey method categories
• skill_to_template() / template_to_skill() — bidirectional DeerFlow bridge
• hybrid_skill_organism() — library-first + generator fallback

Phase C3 — Memory + Thinking

• PrimingView — multi-channel SubstrateView with trust, telemetry, experience
• bridge_animaworks_memory() / bridge_deerflow_memory() — import into BiTemporalMemory
• HeartbeatDaemon — idle-time consolidation
• AsyncOrganizer — Fork/Join execution within stages

Phase C4 — Formal Verification

• 4 TLA+ specs: TemplateExchangeProtocol, DevelopmentalGating, ConvergenceDetection, EvolutionGating
• EvolutionGating.tla — models the A-Evolve Solve→Observe→Evolve→Gate→Reload loop with monotonic score safety
• DesignProblem + compose_series/parallel + feedback_fixed_point — Zardini co-design

Phase C5+ — Decompilers + Capability Annotations

• deerflow_to_topology() / swarms_to_topology() — compile→decompile round-trip with certificate preservation (Prop 5.1 verified)
• ExternalTopology.capabilities — structured per-agent capability annotations consumed by tool_density()
• EXTERNAL_CAPABILITY_MAP — 27 mappings from framework tool names (web_search, python, file_io) to Operon Capability enum values
• RunContext — typed dict subclass wrapping shared_state with property accessors; supports custom WatcherConfig.state_key

Phase C9 — LangGraph Compiler + DeerFlow Executor

• organism_to_langgraph() — compile SkillOrganism to a LangGraph StateGraph. Wraps organism.run() as a single node; all structural guarantees enforced by the organism’s own run loop.
• run_organism_langgraph() — compile + execute in one call with certificate verification
• execute_deerflow() — single-agent execution via DeerFlow’s create_deerflow_agent
• Optional dependency: pip install operon-ai[deerflow] (Python ≥3.12)

Phase C10 — Atomic Skills Catalog

• seed_library_from_atomic_skills() — 5 composable coding skill patterns from Ma et al.: localize, edit, test, reproduce, review
• get_atomic_skill_patterns() — returns deep copies of the built-in catalog
• Topology derived via shared _shape_to_topology(): parallel review → specialist_swarm, sequential skills → skill_organism
• Paper: “Harness Engineering as Architecture” — maps Zhou et al.’s four-pillar externalization framework to Operon’s categorical Architecture triple

Phase C6 — Evaluation Harness

• 21 benchmark tasks across 7 configurations (single, pipeline, fan-out, fan-in, diamond, full, stress)
• MockEvaluator using real structural analysis (topology advice, epistemic bounds, pattern scoring)
• Structural variation analysis: measures how topology metrics change across task configurations
• Credit assignment: attributes evaluation outcomes to individual stage contributions

Phase C7 — Prompt Optimization + Workflow Generation

• PromptOptimizer protocol with NoOpOptimizer reference implementation; EvolutionaryOptimizer extended protocol
• attach_optimizer — attach optimizer to any SkillStage for prompt-level tuning
• WorkflowGenerator protocol with HeuristicGenerator reference implementation; ReasoningGenerator extended protocol
• generate_and_register — generate workflow topology and register it in PatternLibrary

Phase C8 — Meta-Evolution (Phase A complete)

Evolves organism configurations (modes, models, thresholds) using biological primitives at the meta-level. Tests whether Operon’s abstractions generalize from running organisms to evolving them.

• FilesystemOptimizer protocol — distinct from C7’s EvolutionaryOptimizer. Operates on CandidateConfig, not prompts.
• EvolutionLoop — proposes, evaluates via LiveEvaluator, persists to filesystem store
• Hybrid proposers: TournamentMutator (programmatic) + LLMProposer (Gemini/local, rich context)
• Dual stall detection: config novelty (EpiplexityMonitor + DistanceProvider) + score plateau
• Topology mutations (Phase B): edges, add/remove stages, DAG execution via WiringDiagram + ResourceAwareExecutor

Key Findings

Abstraction quality: Genome mapping is lossless (~5 lines). EpiplexityMonitor generalizes across scales. DesignProblem wrapping is natural.

Ao et al. test: Rich context LLM proposer (0.49) slightly outperforms tournament (0.44) but does not dominate. Topology mutations improved tournament (0.60) but degraded LLM (0.36).

Conclusion: Biological abstractions generalize as code structure, not as optimization algorithms. The structural guarantee features (immune system, epiplexity, developmental gating) remain the core value proposition.

Search code lives in eval/meta/ (experimental). Only DistanceProvider remains in the library.

Related: de los Riscos et al. (ArchAgents category theory), Ao et al. (delegation bounds), Meta-Harness (filesystem-backed search).

Examples

• 86–88: Adapter demos (Swarms, AnimaWorks, DeerFlow)
• 89–91: Template exchange, hybrid assembly, skill bridge
• 92–95: Memory bridge, PrimingView, heartbeat, async thinking
• 96: Co-design adapter composition
• 97–98: Ralph hat analysis, A-Evolve workspace analysis
• 99–103: Production runtime — 4 compilers and distributed watcher
• 104: Evaluation harness with MockEvaluator
• 105: Prompt optimization protocols
• 106: Workflow generation and registration
• 107: Live evaluation with real LLM providers
• 108: Meta-evolution of organism configurations