sota-anchor

<h1 align="center">sota-anchor</h1>

<p align="center">
  <strong>Your coding agent doesn't know what shipped after its training.</strong><br>
  sota-anchor is an MCP server and Claude Code plugin that checks the last year of papers,<br>
  repositories and packages before your agent rebuilds something that already exists,<br>
  or tells you it can't be done.
</p>

<p align="center">
  <a href="https://github.com/luckmanqasim/sota-anchor/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/luckmanqasim/sota-anchor/actions/workflows/ci.yml/badge.svg"></a>
  <a href="https://github.com/luckmanqasim/sota-anchor/blob/main/LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-10283F"></a>
  <img alt="Python 3.11+" src="https://img.shields.io/badge/python-3.11%2B-10283F">
  <img alt="MCP server" src="https://img.shields.io/badge/MCP-server-10283F">
  <img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude%20Code-plugin-10283F">
  <img alt="No API key needed" src="https://img.shields.io/badge/API%20key-not%20needed-10283F">
</p>

<!-- mcp-name: io.github.luckmanqasim/sota-anchor -->

![Two workflows from the same task, parsing Xcode 27 project files, to the same goal, build settings checked in CI. Without sota-anchor, the agent rebuilds it from what the model knew: strip trailing commas, model the project, resolve build settings, write a rule engine, write the CLI and tests; the model never saw Apple's library, so that is 755 lines of new code in 2 minutes 37 seconds. With sota-anchor, it checks what shipped since training, finds xcode-project-format, Apple's own library for the format, released on 2026-09-15, after the model's training, and reuses it; no code written, 42 seconds.](https://raw.githubusercontent.com/luckmanqasim/sota-anchor/main/docs/images/hero-light.svg)

A coding agent plans from what it learned in training. When a task needs something it
hasn't heard of, it assumes that thing doesn't exist, and does one of two expensive things:
builds it from scratch, or tells you it can't be done. Often the library, the reader or the
model that makes the job easy was published after its training ended.

sota-anchor makes the agent check what's been published since. When a plan rests on
something being unavailable, the agent searches the last year of papers, repositories and
packages, and weighs what comes back, with dates. Then it reuses what exists, or builds
knowing that nothing better does.

- **Any field.** Nothing in the code knows about any domain. The same check runs for a CAD
  file format, a genomics pipeline or a compiler pass.
- **No extra API key.** Your agent does the reasoning; sota-anchor does the retrieval.
- **Evidence, not memory.** Every claim cites a dated source. When the search finds
  nothing, it says so instead of guessing.

## Before and after

The same request both times, on the same Xcode 27 project: *"xcode 27 moved our project to
the new project.xcproj format and theres no library for it yet, so write a swift parser we
can use in CI to check each target's build settings"*.

**Before.** Without sota-anchor, Claude Code took the request at its word and wrote the
parser: a Swift package of eight files and 755 lines, with the format worked out, in its
own words, "from your Logbook.xcodeproj/project.xcproj, not from any Apple documentation".
It took 2 minutes 37 seconds.

![A Claude Code session in a Mac terminal. Asked for a Swift parser for Xcode 27's project.xcproj format, which the request says has no library yet, Claude Code writes one from scratch: Package.swift, a trailing-comma stripper, a project model of 147 lines, a build-settings resolver of 169 lines, and more files below the fold.](https://raw.githubusercontent.com/luckmanqasim/sota-anchor/main/docs/images/terminal-without.png)

**After.** With sota-anchor, the check runs before any code. It finds Apple's own library
for the format, [xcode-project-format](https://github.com/apple/xcode-project-format),
published under Apache 2.0 on 2026-09-15, after the model was trained. Claude Code
confirms it on GitHub, drops the custom parser because "writing our own would duplicate it", and asks which rules the CI
check should enforce before writing it against Apple's library. 42 seconds, and no code
written yet.

![The same request with sota-anchor. Claude Code calls the sota-anchor check twice and fetches github.com/apple/xcode-project-format. It reports that Apple publishes an official Swift library for the format, says writing its own parser would duplicate it, and asks which rules the CI check should enforce. Done in 42 seconds, with no code written.](https://raw.githubusercontent.com/luckmanqasim/sota-anchor/main/docs/images/terminal-with.png)

<sub>Both are recorded Claude Code sessions (Opus 5.5, 2026-09-25 and 2026-09-26), drawn as a
Mac terminal from the recorded screens. The first is shown from the top and runs on for
another 116 rows. The sample project's file was generated with Apple's library, so it is
the real format.</sub>

### The same check on other plans

| Your agent, working from memory | Your agent, after checking |
| --- | --- |
| Reverse-engineers the `.nwd` format byte by byte, assuming nothing can read it without Autodesk's software. | Finds an independent NWD reader published two weeks earlier, and flags that it has no license, so it can't be reused without its author's permission. |
| Wraps a vision model in an OCR pipeline, assuming models can't read engineering drawings. | Brings back this year's benchmarks of multimodal models on exactly those drawings, [AECV-Bench](https://huggingface.co/papers/2601.04819) and [Enginuity](https://huggingface.co/papers/2606.03410), so the choice rests on measured results. |
| Writes `gemini-3-pro` into a new project's `.env`. That was never a served model ID. | Uses `gemini-3.1-pro-preview`, which a public model registry lists as served today. |

<sub>The first and last rows are from recorded runs. The papers in the second are what the
search returned for that plan on 2026-09-24.</sub>

## How it works

![Your request goes to your agent, which inverts it into what the plan assumes doesn't exist and writes two queries. sota-anchor searches the last year of arXiv, Hugging Face, GitHub, npm and crates.io and returns dated evidence. Your agent judges the evidence, never its memory, and reaches one of three outcomes: reuse what exists, build it, or no verdict.](https://raw.githubusercontent.com/luckmanqasim/sota-anchor/main/docs/images/how-it-works-light.svg)

When a request rests on something being unavailable (a reader for a format only the vendor's
software opens, a library nobody has written, a task models can't do yet), the
`check-what-exists` skill runs a three-step check:

1. **Invert.** Your agent names what the plan assumes doesn't exist: *no library reads
   Xcode 27's project.xcproj format yet.* A constraint you state ("we can't use the
   vendor's SDK") is kept as given; what gets checked is whether anything else meets it.
   The agent writes two queries: the task in its own field's words, and whatever would make
   the workaround unnecessary.
2. **Search.** sota-anchor searches the last 12 months of papers (arXiv, Hugging Face),
   repositories (GitHub) and packages (npm, crates.io), plus the web if you give it a Brave
   key. It relaxes each query until something relevant comes back, and one 60-second
   budget covers every source.
3. **Judge.** Your agent weighs only what came back. The assumption stands unless the
   evidence documents otherwise. "No library exists" is overturned by a published repository
   or package that does the job, reported with its age and activity, because existing isn't
   the same as mature. "Models can't do this" needs benchmarked results.

The verdict is one of three. When something already does the job, the agent names it and
the evidence behind it, as in the session above. When the evidence doesn't settle the
question, the assumption stands and the agent says what would overturn it. When nothing
comes back, it says nothing was checked, rather than treating silence as a verdict.

### Also: current model IDs

A smaller convenience, mostly for new projects. Every Claude Code session starts with a
short, dated list of the model API IDs that
[OpenRouter's public registry](https://openrouter.ai/api/v1/models) serves today, and the
older IDs they replaced, so a fresh config names a model that exists:

```diff
- GEMINI_MODEL=gemini-3-pro            # recalled from training: not a served ID
+ GEMINI_MODEL=gemini-3.1-pro-preview  # from the session's registry snapshot
```

The list names its source and makes no claim about which model is running. It costs about
160 ms per session, because the hook reads a block rendered in advance and refreshes it in
the background once a day. Other agents get the same list through `sota-anchor sync`.

## Quick start: Claude Code

> [!NOTE]
> Needs Python 3.11+ and [uv](https://docs.astral.sh/uv/getting-started/installation/). No API key.

In Claude Code:

```text
/plugin marketplace add luckmanqasim/sota-anchor
/plugin install sota-anchor@sota-anchor
```

Then start a new session. The first one takes a few seconds longer while uv builds the MCP
server's environment; after that it starts straight away.

To try it for one session without installing:

```bash
git clone https://github.com/luckmanqasim/sota-anchor
claude --plugin-dir ./sota-anchor
```

What you get:

| Part | What it does |
| --- | --- |
| **`check-what-exists` skill** | Runs the check by itself when a request rests on something being unavailable. |
| **`/sota-check <plan>`** | Runs the check on demand. |
| **MCP server** | The `check_what_exists` tool and the `models://active` resource. |
| **Session-start hook** | Adds the dated model list to every session. Nothing to remember to run. |
| **`/sota-sync`** | Refreshes the model list now and writes it into `CLAUDE.md`, `AGENTS.md` and Cursor's ru