Kerno

The description states that Kerno is a local-first context intelligence and model-orchestration layer for Codex. It builds a closed-loop system:

• Task → classification → minimal context capsule → Codex action → test/runtime evidence → targeted expansion or invalidation → verified result.

It uses:

• Git-aware incremental indexing;
• Symbol, import, test, configuration, and hash-based context building;
• SQLite/WAL for local state;
• A React/Vite dashboard for inspecting the process;
• 16 structured MCP tools;
• Codex plugin and App Server integration;
• Evidence-backed memory and invalidation logic.

It is not described as generic RAG but as a system focused on evidence maintenance—why context is trusted, what could falsify it, and how the system responds when reality proves it incomplete.

The description states that Kerno’s positioning is:

• To solve the problem of maintaining “the right beliefs about a changing codebase” in agentic coding;
• To provide a system where context can be admitted as incomplete, repaired from evidence, and proven correct;
• To avoid dumping entire repositories and instead build bounded, explainable capsules.

It claims to be not generic repository RAG, but a system focused on:

• Context validity;
• Falsifiability of context;
• Model routing that distinguishes between recommendation, request, and effective execution.

The project also emphasizes transparency in model routing and evidence tracking. The authors state they are not making productivity or token-saving claims, but rather correctness-first claims.

The description states that Kerno is built for developers working with Codex, particularly those using it for agentic coding tasks involving complex repositories.

It targets users who:

• Work in environments where repository context changes frequently;
• Need to maintain accurate beliefs about codebase state;
• Want to avoid over-fetching or stale context during task execution;
• Are interested in evidence-backed model routing and transparent system behavior.

There is no explicit mention of enterprise customers, specific verticals, or personas beyond developers using Codex.

The description does not provide any information on pricing, monetization, or business model. It states that Kerno is local-first, with no mandatory hosted backend, vector database, or third-party service. The website is a read-only replay and does not accept repository source.

No revenue, customer data, or pricing structure are mentioned.

The project is built as a strict TypeScript and npm-workspaces monorepo using:

• Git-aware incremental indexer;
• JavaScript/TypeScript and Python parsers;
• SQLite/WAL for local state;
• React/Vite dashboard;
• 16 strictly validated MCP tools;
• Codex plugin and App Server integration;
• Playwright flows, unit tests, and security checks.

It supports:

• Branch-, commit-, file-, worktree-, and symbol-aware invalidation;
• Local-first design with no telemetry or hosted components;
• Independent review threads;
• Plugin mode and orchestrator mode for model routing.

The system is described as not using vector databases or third-party services, and it avoids turning missing data into zero.

There is no evidence of traction beyond the hackathon submission. The project:

• Has a working demo;
• Includes 76 deterministic tests and 12 Playwright flows;
• Has a public read-only replay at https://itkerno.site;
• Was built in a short timeframe (hackathon);
• Does not report any customers, revenue, or usage metrics.

The authors note that the project is a hackathon submission, with no data on product-market fit or real-world adoption.

The description does not mention specific competitors. It positions itself as distinct from generic repository RAG and emphasizes:

• Evidence-backed context;
• Model routing transparency;
• Local-first design;
• Falsifiability of context.

It is unclear whether Kerno competes with other Codex plugins, agent frameworks, or repository search tools.

• No real-world usage or adoption beyond the hackathon.
• Self-reported claims only, no independent verification.
• No revenue, customers, or traction data provided.
• The system is described as local-first and not hosted — this may limit scalability or ease of adoption.
• The project is a single-person effort (team size: 1).
• The authors note that they do not make productivity or token-saving claims, but correctness is emphasized — this could be a limitation if users prioritize speed over accuracy.

1. What is the actual use case for Kerno beyond the demo? Is it being used in any real development workflows?
2. How does Kerno handle concurrency when multiple tasks are running simultaneously in Codex?
3. Are there plans to support hosted or cloud-based components, or will it remain strictly local-first?
4. Has the system been tested with larger or more complex codebases beyond the demo?
5. What is the long-term vision for model routing and integration with other AI agents or tools?
6. How does Kerno handle edge cases in invalidation logic (e.g., when a file is deleted or renamed)?
7. Are there any plans to open-source parts of the system, or to support third-party integrations?