Knowledge Patch for coding agents
Model knowledge fades before the published cutoff
AI labs assign each model a single knowledge-cutoff date, but recall becomes unreliable well before that point. The decline is uneven: a model may know one technology released near the cutoff in detail while struggling with another that had been available for years.
The curve shows that decline. The area above it represents relevant information the model cannot reliably recall, including gaps it may not recognize on its own. Knowledge Patch supplies that information through a local, model-specific reference for Claude Code and Codex. The plugin is free and MIT-licensed.
Documentation alone cannot reveal where those gaps are because they depend on the model: what appeared in its training data, how often it appeared, and how reliably the model learned it. Even an older library can remain a weak spot when the available examples were sparse.
Measuring the effect of a patch
The evaluation runs the same model on the same tasks and prompts, changing only whether the patch is loaded. Moving up and left means a higher score at a lower cost.
Whiskers show one standard error across the task set. Cost uses API-equivalent pricing and is measured per task. The published results include everything required to reproduce each run.
Each model gets a different patch
We generate a separate patch for each model. Codex receives topics that GPT struggles to recall, while Claude Code receives topics that Claude struggles to recall. The resulting files differ even when they cover the same technology.
Choose an example
17% of Bun topics differ by model
Bun.sql pipelining and .execute()
Queries are pipelined by default, so Bun can send a query before the previous response arrives. Calling .execute() starts a query eagerly without awaiting it, which lets you start an entire batch and await it later.
Other topics unique to this patch
- Faster barrel imports with optimizeImports
- customSQLiteBinary in bun:sqlite
- YAML 1.2 parses yes / no as strings
Included for GPT
New Promise APIs
Promise.withResolvers() returns { promise, resolve, reject }. Promise.try(fn, ...args) wraps either a synchronous or asynchronous function call in a promise without creating a new Promise() executor.
Other topics unique to this patch
- bun install --frozen-lockfile with overrides
- Concurrent, randomized and CI-safe tests
- --max-concurrency defaults and limits
A generic reference sends every model the same material. Knowledge Patch measures each model first, so its patch can focus on that model's gaps.
Outdated code can pass every check
You ask an agent to implement a ticket for PostgreSQL 18. It writes clean, passing code with the PostgreSQL 16 patterns it knows well. A better PostgreSQL 18 approach exists, but the compiler, tests, and code review offer no clue that the agent missed it.
Web search starts with a question, and the agent has no reason to ask one here. Searching broadly during every task would also be slow, unreliable, and use a large share of the context window. Unless someone prompts it to check the newer release, the older code ships.
How we build each patch
We test a specific model to identify gaps in its knowledge of a technology, then write a concise working reference that covers them. We repeat the tests from scratch for every new model because the results differ.
We keep the evaluation pipeline private so its benchmarks stay out of future training data and continue to produce useful results.
Every published patch is MIT-licensed Markdown that anyone can read, diff, fork, and modify. Trusted maintainers can join the evaluation process, and businesses can license it for in-house use.
Local files you can inspect and pin
Knowledge Patch is offline and Zero Data Retention (ZDR) by default. Every patch is documented and version-pinned, making it suitable for Software as a Medical Device (SaMD), defence, and other audited environments. Instead of trusting an unseen backend, you review the files already on your machine.
Runs entirely on your machine
The plugin needs no API key, account, or lookup service. During use, your queries, code, and prompts stay on your machine.
Pinned releases stay reproducible
A pinned release contains a fixed set of files. It delivers the same content today and in six months, on a laptop or in CI, for every engineer on the team.
Review content before the agent sees it
A retrieval service can place unreviewed content directly into an agent's context. A pinned local patch can be inspected before use and cannot change between reviews.
- 1.update
- 2.review
- 3.use
Security guidance also goes stale
Newly disclosed vulnerabilities can become exploitable quickly. An agent with an outdated view of a library may keep generating patterns that were safe at training time but have since become dangerous.
Compilers, tests, and screenshots help agents catch many of their own mistakes. They rarely flag code that compiles, passes, and remains vulnerable. Knowledge Patch includes current security guidance alongside API changes. The React patch, for example, covers RSC request-decoding vulnerabilities and the corresponding framework updates.
Patches for the tools developers use
Search for a technology below. Each result is a skill included with the plugin, and your agent loads the relevant patch when it works with that technology.
Coverage for niche and industrial stacks
Coverage extends beyond mainstream developer tools to industrial automation and robotics. You can request any other technology or topic.
Weekly updates with explicit coverage
Each patch states exactly how far its coverage extends, such as React 19.2.0 or PostgreSQL 18.0. The explicit boundary makes freshness easy to check.
Install the plugin locally
Claude Code and Codex have first-class support. Any agent that supports plugins or skills can use the same patches, including Cursor, Copilot, OpenCode, and Antigravity.
/plugin marketplace add nevaberry/nevaberry-plugins /plugin install knowledge-patch@nevaberry /knowledge-patch:knowledge-patch-setup
Codex CLIcodex plugin marketplace add nevaberry/nevaberry-plugins codex plugin add knowledge-patch@nevaberry
Start a new session, then run $knowledge-patch-setup
npx skills add Nevaberry/nevaberry-plugins
This command installs the patches as portable skills. Model-specific tailoring is available for Claude and GPT; other agents use the general versions.
Keep the patches current
Claude Code: enable marketplace auto-updates
Claude Code leaves auto-update off for third-party marketplaces. Turn it on with /plugin → Marketplaces → nevaberry → Enable auto-update.
Codex: updates automatically
Codex refreshes changed plugins from configured marketplaces at startup. To force an update, run: codex plugin marketplace upgrade nevaberry
Pin the installed version
For air-gapped or regulated environments, this setting keeps the installed version fixed: DISABLE_AUTOUPDATER=1
Free and MIT-licensed
You get the complete plugin under the MIT license, with no trial period or usage quota. It runs locally, so there is no metered lookup. The project began as a practical fix for agents that kept generating outdated code for niche crates.io libraries.
Sponsor a model
Estimated API cost: ~$5k/month
Running extraction is expensive. Personal funding currently covers Claude and GPT. Sponsorship would fund extraction for Gemini, Grok, Qwen, or DeepSeek and make that model's patch available to everyone.
Sponsor a technology
Typical range: free–$500+/month
You can request any technology or topic, including specialized industrial and robotics stacks. The resulting patch is published free for everyone.
Service-level agreement
Typical range: $100–$1k/month
Organizations can pay for guaranteed update schedules, coverage commitments, response times, and priority requests. They can also license the process for in-house use.
Sponsors and SLA customers fund commitments such as update schedules and response times. Every user receives the same free plugin and the same published patches.
Common questions
Will a static package go stale?
We run the mining process weekly, and release watchers detect new versions within a day. Every patch states its coverage boundary, so you can see exactly how current your installed version is.
Why not let the agent search the web?
You can use both. Knowledge Patch provides relevant material before the agent realizes it needs to look something up; web search handles questions the agent has already identified. An unrecognized gap gives the agent no reason to search.
What usage data is collected?
Knowledge Patch collects no usage data. Only GitHub sees the request when you download or update the plugin and can count that download. The public repository does not expose that count to me. After installation, operation is entirely local and private: no telemetry, queries, code, or prompts are sent anywhere.
What happens if maintenance stops?
The published patches are MIT-licensed and forkable. Organizations can license the process for in-house use, and trusted maintainers can join the project.
Why keep the build process private?
The method depends on benchmarks that reveal what a model has failed to learn. Once a benchmark enters training data, it can no longer measure that gap and must be rebuilt. We publish the generated patches and keep the evaluation suite private to protect that measurement.