📣 Announcement: Right Brain, Procedural Seed Cortex (In Development)
Status: In active development. Not yet part of the released weights.
The Kronumos Dual-Brain architecture is getting its next major component: the Right Brain, a cortex built entirely on Procedural Seeds.
Today, Kronumos Kairos pairs a neural Cortex (Qwen2.5-Coder-7B reasoning) with a deterministic Sub-Cortex (native Rust AST slicing and healing). The Right Brain adds a third pillar that works on a different principle: instead of generating a repair from learned weights, it derives repair strategies from compact procedural seeds (<64 bytes each), expanded deterministically at runtime with no database lookups.
What this adds
Table with columns: Component, Role, Nature| Component | Role | Nature |
|---|
| Left Brain (Cortex) | Semantic reasoning, 5-step CoT, code hunk generation | Parametric / neural |
| Right Brain (new) | Seed-driven strategy generation and pattern intuition | Procedural / seed-based |
| Sub-Cortex | AST validation, bracket and indent healing, Merkle ledger | Deterministic / Rust |
Design goals
- Zero-DB, seed-native: strategies are regenerated from seeds, not retrieved from storage.
- Reproducible: the same seed always yields the same strategy.
- Tiny footprint: seeds stay in the L1 cache, with no extra VRAM requirement.
- Integrated with the Dual-Key Consensus Gate: Right Brain proposals must pass the same semantic and AST validation as every other candidate.
Roadmap
Results and benchmarks for the Right Brain will be published only after full evaluation. Follow the GitHub repository for updates.
🏛️ The Kronumos Dual-Brain Family Portfolio
Table with columns: Tier, Model, Parameters, Target Workload, Latency / Footprint| Tier | Model | Parameters | Target Workload | Latency / Footprint |
|---|
| Edge / Workstation | Kronumos 2 Kairos | 7.6B | Rapid local bug remediation, offline laptops, CI/CD gates | <2.5s / 4-bit 5.5 GB VRAM |
| Edge / Sovereign | Kronumos 14B Kairos | 14.7B | Complex algebraic, cross-module AST repairs (sympy, sphinx) | <4.5s / 4-bit 9.2 GB VRAM |
🥊 Benchmark Verification: SWE-bench Verified (500 Instances)
Evaluated end-to-end on the official Princeton SWE-bench Verified benchmark (500 production instances across Django, Scikit-Learn, PyData Xarray, Sphinx, Sympy, etc.) using official Docker execution containers.
Table with columns: Metric, Kronumos 2 Kairos, Industry Multi-Turn Baselines| Metric | Kronumos 2 Kairos | Industry Multi-Turn Baselines |
|---|
| Model Size | 7B Parameters | 70B - 405B / Frontier APIs |
| Execution Mode | Single-Pass Zero-Shot | Multi-Turn Agent Loop (50-100 Turns) |
| Avg Tokens / Task | 2,512 Tokens | 40,000 - 150,000 Tokens |
| Token Efficiency | 93.5% Reduction | Baseline (1.0x) |
| API Cost | $0.00 (Pure Local Weights) |
🏆 Verified Resolved Production Issues:
django__django-13569: Broken aggregation expression logic in database queries.
django__django-13658: Management command argument parser collision.
django__django-14855: Admin URL generation prefix regression.
django__django-15104: Model custom key migration constraint hazard.
django__django-16333: Many-to-many relationship foreign key mapping.
pydata__xarray-4629: Multi-index coordinate slice dimension regression.
scikit-learn__scikit-learn-10844: Pipeline estimators parameter validation fault.
sphinx-doc__sphinx-8595: Python domain autodoc signature formatting error.
🔬 The Dual-Brain Cybernetic APR Architecture
Traditional LLM agents rely exclusively on multi-turn prompt loops, generating massive token overhead and hallucinating syntax formatting. Kronumos Kairos decouples cognition into two integrated computing cortices:
[Raw GitHub Issue Discussion] │ ▼ ┌──────────────────────────────────┐ │ Sub-Cortex IssueDeNoiser │ │ - Excises human chatter/quotes │ │ - Tags user reproduction code │ │ - Extracts Core Signal Triad │ └────────────────┬─────────────────┘ │ [Cleaned Technical Specification] │ ▼ ┌──────────────────────────────────┐ │ Procedural Cognitive Kernel │ ◄─── Procedural Seeds (<64 bytes) │ - BoundaryCondition Invariants │ (Zero-DB L1 Cache Execution) │ - DefensiveNullWrap / PopGuards │ └────────────────┬─────────────────┘ │ ┌────────────────────┴────────────────────┐ ▼ ▼┌───────────────────────┐ ┌───────────────────────┐│ CORTEX (Neural) │ │ SUBCORTEX (Deterministic)│ Qwen2.5-Coder-7B │ ◄─────► │ Tree-sitter AST Slicer││ - 5-Step CoT Reason │ Dual-Key│ Auto-Bracket & Indent ││ - Precise Code Hunk │ Consens.│ Merkle Causal Ledger │└───────────────────────┘ └───────────────────────┘
- Issue De-Noiser: Strips human conversational chaff, extracting the core reproduction triad.
- Procedural Cognitive Kernel: Diagnoses invariants across 9 domains (Boundary, Defensive, Concurrency, etc.) without external database lookups.
- Dual-Key Consensus Gate: Requires simultaneous semantic approval and deterministic AST validation before admitting state changes.
- Auto-Bracket & Indentation Healer: Deterministically balances parentheses and enforces strict PEP 8 4-space block indentation.
⚡ Native Rust Sub-Cortex Runtime
This repository includes the precompiled native Linux x86_64 binary libtokenectomy_subcortex.so and Python C-ABI bridge tokenectomy_subcortex_rust.py.
from tokenectomy_subcortex_rust import RustSubCortex subcortex = RustSubCortex() # 1. Clean noisy issue descriptions (93.5% token reduction)clean_spec = subcortex.denoise_issue(raw_github_issue) # 2. Heal indentation drift and unbalanced brackets with sub-microsecond latency (5µs)healed_code = subcortex.heal_indentation(candidate_code, base_indent=4)
💻 Quickstart: Running Inference
import torchfrom transformers import AutoModelForCausalLM, AutoTokenizer model_id = "NadevA23/Kronumos-Kairos-v2"tokenizer = AutoTokenizer.from_pretrained(model_id)model = AutoModelForCausalLM.from_pretrained( model_id, torch_dtype=torch.bfloat16, device_map="auto") messages = [ {"role": "system", "content": "You are Kronumos Kairos, an expert autonomous program repair engine."}, {"role": "user", "content": "Fix the issue in the following function:\n\ndef safe_divide(a, b):\n return a / b"}] inputs = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)outputs = model.generate(inputs, max_new_tokens=512, do_sample=False)print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))
Quantized GGUF (Llama.cpp / Ollama):
For quantized local execution on consumer hardware, visit NadevA23/Kronumos-Kairos-v2-GGUF.
📜 Citation
@article{daffa2026kronumos2, author = {Muhammad Naufal Daffa}, title = {Kronumos 2 Kairos: Cost-Bounded Automated Program Repair via Dual-Brain Cybernetic Sub-Cortex on SWE-bench Verified}, journal = {Research Square}, year = {2026}, doi = {10.21203/rs.3.rs-11205335/v1}, url = {https://doi.org/10.21203/rs.3.rs-11205335/v1}}
License: Apache 2.0
Maintained by: Tokenectomy Labs