Chronos-1

The first debugging focused language model built for full repository scale understanding, multi file reasoning, and autonomous code maintenance.

Chronos delivers industry leading debugging accuracy, cross file retrieval, and repository aware analysis as part of the Kodezi platform. It is the core intelligence layer powering Kodezi OS and will be publicly available in Q1 2026.

Overview

Chronos is a debugging first language model developed by Kodezi. Unlike traditional code generation models, Chronos is trained and optimized specifically for repair, diagnosis, and reasoning across entire codebases. It works with real errors, logs, stack traces, diff history, and real test feedback.

Chronos is built to fix real bugs, improve code health, and maintain large codebases with the capabilities required for modern software teams.

Availability Timeline

Chronos will be available through:

Q4 2025 (Beta Access)

• Kodezi OS (limited beta for early users)
• Kodezi CLI (Pro users)
• Kodezi Web IDE (Pro users)

Q1 2026 (General Availability)

• Kodezi OS (desktop and enterprise environment)
• Kodezi CLI (command line interface)
• Kodezi Web IDE (browser based development)
• Kodezi API (for team and enterprise integration)

The model comes fully packaged and integrated into each platform. No separate installation or API key management required for Kodezi OS and CLI users.

Links

• Official Website: https://chronos.so
• GitHub Research Repository: https://github.com/kodezi/chronos (Contains paper, benchmarks, architecture docs, evaluation results)
• Early Access Waitlist: https://kodezi.com/os
• Research Paper: https://arxiv.org/abs/2507.12482

What Chronos Does

Chronos is designed for one purpose: solve real world debugging and maintenance tasks at repository scale.

Key capabilities

• Understands entire repositories of any size using intelligent retrieval
• Detects and explains root causes of failures
• Generates multi file patches with tests
• Runs fixes through automated validation loops
• Learns from each debugging session
• Reduces debugging time for teams and enterprise organizations
• Produces validated, production ready patches

Chronos is a full debugging engine, not just a code assistant.

Core Principles

Debugging First

Chronos is trained on 42.5 million real debugging examples rather than code completion tasks. The training corpus includes:

• 15 million GitHub issues with linked PRs and fix commits
• 8 million stack traces paired with resolutions
• 3 million CI/CD logs from failed and fixed builds
• 2.5 million production debugging sessions from real world environments
• 14 million examples from curated benchmarks (Defects4J, SWE bench, BugsInPy)

This specialized training enables Chronos to handle real scenarios including:

• multi file failures
• stack trace interpretation
• regression analysis
• dependency issues
• version drift
• performance and concurrency bugs

Repository Scale Intelligence

Chronos dynamically retrieves the exact context needed from large codebases through its Adaptive Graph Guided Retrieval system.

This allows Chronos to understand code relationships across:

• call graphs
• imports
• tests
• historical changes
• execution flow
• logs

Chronos handles repositories up to 10 million lines of code through intelligent context assembly rather than brute force token windows.

Autonomous Fix Loop

Chronos runs a fix cycle:

1. Analyze error
2. Retrieve relevant parts of the repository
3. Produce a candidate patch
4. Run tests in a sandbox
5. Refine until successful
6. Produce validated fix, explanation, and documentation

This loop operates automatically inside Kodezi OS or Kodezi CLI. The average debugging session completes in 7.8 iterations with a 67.3 percent fully autonomous success rate.

High Level Architecture

This section provides a simplified view of how Chronos works.

1. Multi Source Input Layer

Takes in code, logs, stack traces, tests, documentation, and commit history.

Unlike traditional models that only process source files, Chronos natively understands debugging artifacts including CI/CD logs, error traces, stack dumps, configuration files, historical PRs, and issue reports.

2. Adaptive Retrieval Engine

Finds the exact files, functions, and history needed with high precision. Operates through multi hop dependency traversal and contextual graph search.

The Adaptive Graph Guided Retrieval system uses:

• Dynamic k hop neighbor expansion based on query complexity
• AST aware code embeddings that preserve structural relationships
• Dependency graph indexing for cross file impact analysis
• Call hierarchy mapping for execution flow understanding
• Temporal indexing of code evolution and bug history
• Confidence based termination for optimal context assembly

3. Debug Oriented LLM Core

A transformer architecture specifically fine tuned on debugging workflows, not just code completion.

Trained specifically for:

• bug diagnosis
• multi file patch generation
• test failure interpretation
• reasoning under uncertainty
• root cause prediction from symptoms
• regression risk assessment

4. Orchestration Controller

Runs iterative fix cycles with test feedback and refinement.

Implements the autonomous debugging loop including:

• Hypothesis generation from error signals
• Iterative fix refinement based on test results
• Rollback mechanisms for failed attempts
• Confidence scoring for proposed solutions

5. Persistent Debug Memory

Learns from previous bugs inside the same repository. This improves Chronos each time it debugs a project.

Maintains long term knowledge including:

• Repository specific bug patterns and fixes
• Team coding conventions and preferences
• Historical fix effectiveness metrics
• Module level vulnerability profiles

The Persistent Debug Memory learns from over 15 million debugging sessions and improves from 35 percent to 65 percent success rate as it accumulates repository specific knowledge.

6. Execution Sandbox

Validates patches through real tests and runtime checks.

Real time validation environment supporting:

• Isolated test execution
• CI/CD pipeline emulation
• Performance regression detection
• Security vulnerability scanning

Every proposed fix runs in a containerized sandbox with comprehensive validation including unit tests, integration tests, linting, and type checking.

7. Explainability Layer

Produces human readable root cause explanations, patch summaries, and documentation updates.

Generates:

• Root cause explanations with evidence chains
• Fix rationale documentation
• Automated PR descriptions and commit messages
• Risk assessment reports

Performance Summary

Chronos reaches state of the art debugging performance on real world challenges.

Highlights

• 80.33 percent on SWE bench Lite
• 67.3 percent real world fix accuracy on large multi file scenarios
• 89 percent human preference in blind evaluations
• 40 percent time reduction compared to manual debugging
• Strong performance on complex domains such as Django, SymPy, and Sphinx
• 4 to 5 times improvement over general language models on multi file debugging tasks

Chronos is the first model specifically built for debugging workflows rather than code completion.

The Debugging Gap

While models like Claude 4.5 Sonnet and Claude 4.1 Opus achieve over 70 percent on code generation tasks, they drop to below 15 percent on debugging tasks. This reveals a 50 to 60 percentage point gap between code generation and debugging performance.

Chronos bridges this gap:

• Claude 4.5 Sonnet: 72.7 percent code generation, approximately 14 percent debugging (gap of 58.7 percentage points)
• Claude 4.1 Opus: 72.5 percent code generation, 14.2 percent debugging (gap of 58.3 percentage points)
• GPT 4.1: 54.6 percent code generation, 13.8 percent debugging (gap of 40.8 percentage points)
• Kodezi Chronos: 80.33 percent debugging (specialized for debugging from day one)

This demonstrates that debugging requires specialized architectures and training, not just larger context windows.

SWE bench Lite Results

Chronos achieves state of the art results on the industry standard SWE bench Lite benchmark as of November 2025:

• Rank 1: Kodezi Chronos at 80.33 percent (241 out of 300 instances)
• Rank 2: ExpeRepair v1.0 with Claude 4.5 Sonnet at 60.33 percent (181 out of 300)
• Rank 3: Refact.ai Agent at 60.00 percent (180 out of 300)
• Rank 4: KGCompass with Claude 4.5 Sonnet at 58.33 percent (175 out of 300)
• Rank 5: SWE agent with Claude 4.5 Sonnet at 56.67 percent (170 out of 300)

For reference, general purpose models without agent frameworks:

• Claude 4.5 Sonnet Bash Only: approximately 14 percent (42 out of 300)
• Claude 4.1 Opus Bash Only: 14.2 percent (43 out of 300)
• GPT 4.1: 13.8 percent (41 out of 300)

Chronos holds a 20 percentage point absolute lead over second place, representing a 33 percent relative improvement achieved through debugging specific training on 15 million sessions, Persistent Debug Memory for cross session learning, Adaptive Graph Guided Retrieval for multi hop code understanding, and autonomous fix test refine loops.

Repository Specific Performance

Chronos excels across different types of projects:

• SymPy (symbolic mathematics): 96.1 percent success (51 out of 53 instances) demonstrating near perfect mathematical reasoning
• Sphinx (documentation systems): 93.8 percent success (60 out of 64 instances) showing exceptional performance on doc generation bugs
• Django (web frameworks): 90.4 percent success (104 out of 115 instances) proving capability on complex framework debugging

Multi Random Retrieval Benchmark

Chronos was evaluated on 5,000 multi random retrieval scenarios designed to test real world debugging complexity. A sample dataset of 500 scenarios is publicly available now with the full benchmark releasing in Q1 2026.

The benchmark simulates real world debugging by distributing bug context across 10 to 50 files with temporal dispersion from 3 to 12 months of history and varying obfuscation levels.

Key results compared to GPT 4.1, Claude 4.1 Opus, and Gemini 2.0 Pro:

• Debug Success Rate: 67.3 percent plus or minus 2.1 percent (versus 13.8 to 15.0 percent for baselines)
• Root Cause Accuracy: 89 percent (versus 11.7 to 15.8 percent for baselines, 5.6 to 7.6 times better)
• Retrieval Precision: 92 percent (versus 67 to 74 percent for baselines)
• Retrieval Recall: 85 percent (versus 32 to 42 percent for baselines, 2.0 to 2.7 times better)
• Average Fix Iterations: 7.8 (versus 1 to 2 for baselines, more thorough)
• Time Reduction: 40 percent faster than manual debugging

Statistical significance confirmed with p less than 0.001 compared to best baseline using two tailed t test with n equals 5,000.

Performance by Bug Category

Chronos handles different types of bugs with varying degrees of success:

• Syntax Errors: 94.2 percent (1.1 times better than baselines)
• Logic Bugs: 72.8 percent (6.0 times better than baselines)
• Concurrency Issues: 58.3 percent (18.2 times better than baselines)
• Memory Problems: 61.7 percent (10.8 times better than baselines)
• API Misuse: 79.1 percent (4.2 times better than baselines)
• Performance Bugs: 65.4 percent (8.8 times better than baselines)

Chronos shows dramatic advantages on complex bug types like concurrency issues and memory problems where traditional models achieve less than 7 percent success.

Performance at Scale

Chronos performance across different repository sizes demonstrates it is specifically designed to handle large repositories where traditional models struggle:

• Repositories under 10,000 lines: 71.2 percent plus or minus ...