Codex understands code. Kovacs helps it understand the work.

Codex understands code. It does not always understand what I am trying to achieve.

That distinction became harder to ignore as I used coding agents on longer projects. A model could analyze a function, repair a test or explain an error in seconds. But it did not necessarily know my objective for the day, what I had already attempted, which decision from last week still constrained the solution, or whether the activity on my screen was moving the project forward at all.

The limitation was not code generation. It was context — not context as in a larger prompt, but context as an operating system: the right objective, memory and evidence, retrieved at the right moment, under an explicit authority boundary. So I started engineering Kovacs.

A context layer, not another coding agent

Kovacs is a local-first Windows desktop system that sits above Codex CLI. I give it a longer-term mission and a daily intention. It turns that intention into a measurable objective and a small set of checkpoints, observes only the desktop applications I authorize, retrieves relevant project memory and decides whether there is enough evidence to recommend a next step.

Codex CLI remains the only reasoning gateway. Kovacs does not compete with it at reading a stack trace or finding a bug. Its job is to assemble the broader situation before asking for reasoning — and, most of the time, to decide that no model call is justified.

Context is a pipeline

Building this involved much more than connecting an interface to a model. Desktop context is incomplete, noisy and potentially sensitive. Memory can be stale. A user's statement about progress is not the same thing as a test result. An interruption that arrives without enough evidence is worse than silence. Those constraints shaped the architecture.

• A progressive perception cascade starts with application metadata and Windows UI Automation, falls back to local OCR when necessary, and only considers a screenshot when additional visual context is both useful and safe.
• Project-scoped memory lives locally in SQLite, with retrieval designed to recover relevant constraints without turning the entire history of a project into one enormous prompt.
• User reports, system inferences and tool- or artifact-verified evidence remain distinct. Kovacs never silently upgrades confidence because a statement sounds plausible.
• Sensitive-content guards run locally before captured context can reach the reasoning layer. Unsafe or ambiguous context fails closed.
• Interrupted sessions recover their state, but observation never silently resumes after restart. The user has to restore that authority.
• Token use, latency and intervention feedback are measurable because usefulness without an operating cost is not a useful product metric.

Silence is a feature

The easiest version of this product would send every desktop observation to a model. It would also be expensive, invasive and unbearable to use. Kovacs instead runs a deterministic local decision gate over semantic change, confidence, repeated context, failure signals, cooldowns and previous feedback. Sampling the screen does not imply calling Codex. The normal outcome is silence.

That choice changes the character of the system. AI is not a permanent narrator watching me work. It becomes a bounded escalation path that local software can invoke when the available evidence suggests that reasoning may actually help.

Evidence before progress

A coding session can feel productive while producing nothing reviewable. Files are open, hypotheses multiply, prompts get longer — but there is no isolated failure, passing test, benchmark, artifact or decision. Kovacs treats that gap as part of the engineering problem.

If I am debugging, it should notice when I change several variables before isolating the failure. If I am making an architectural decision, it should recover the constraints I established earlier. If I work for hours without producing verifiable evidence, it should question whether I am progressing instead of congratulating me for being busy.

Authority is part of the architecture

Kovacs is advisory-only. It cannot click, type, edit project files, submit forms, publish content or commit code. That is not a temporary limitation disguised as a roadmap item. It is a product boundary. The system may structure work, retrieve memory, observe authorized context and draft a recommendation; the engineer remains responsible for deciding and acting.

The boundary keeps the feedback loop legible. When something changes in the repository, I know who changed it. When an intervention was useful, I can say why. When it was noise, that failure becomes input to the policy rather than another autonomous action to unwind.

From implementation to sustained use

The current version, v0.3.3, supports mission and daily planning, contextual desktop observation, local scoped memory, evidence-bearing checkpoints, privacy controls, recovery, backup and export. Its repository gate currently passes 56 automated tests and 14 release criteria, with 90% Top-5 recall on the present deterministic ten-case retrieval corpus. Those are engineering checks, not claims of production effectiveness.

The next phase is deliberately less glamorous: sustained usage. I am measuring when interventions help, when they become noise, how much context is actually necessary and what each useful recommendation costs in latency and model usage. The question is no longer whether the architecture can produce guidance. It is whether that guidance earns the interruption.

And yes, Kovacs is a narwhal.