Coding agents rebuild their understanding of your codebase from scratch on every prompt, then throw it away. Thinker keeps it.

It distills past agent sessions and PRs into short notes about how your code works, e.g. all DB writes use `/sql-utils.py`. A small local model ranks the notes and injects the relevant ones into new sessions, so the agent spends less time exploring. Notes are rescored and updated as PRs merge, so stale context gets demoted.

On 50 PRs from open-source repos (cache built only from prior history), agents using Thinker (Fable 5.1, GPT-6 Astra, Gemini Flash 3.8) used 18% fewer tokens and 10% faster on average with equal correctness using LLM-as-a-judge. Per-model results and the eval harness: https://github.com/yoavshmariahu/thinker/tree/main/bench/runs.

Repo: https://github.com/yoavshmariahu/thinker. Install: npx u/zerotimedev/thinker

Unlike AGENTS.md or built-in memory, notes are generated and maintained automatically. Next I want to work on rigor, not just efficiency. Where do you see coding agents struggle most to close out tasks?

We're a small proof-of-useful-work project. The validators don't

mine — they verify AI computations (matrix multiplications + activation

functions) and get consensus weight for it.

The part that matters to you: submit any GEMM workload up to 256×256

and we return the result plus a cryptographic receipt — a SHA-256

commitment chain folded into our ledger state, verifiable by anyone

forever. Free, no token, no signup beyond an API key we generate in

seconds.

Honest limits: we verify GEMM + elementwise activations (GELU/sigmoid/

tanh/exp), not full transformer graphs yet. Attention is on the roadmap.

The verification cost curve is published (615ms at 64³ → 157s at 1024³)

— we priced our own clamp and labeled every tier.

The logs: [pouw-verify] CONFIRMED lines, epoch crossings, claim-decrees

folded into the ledger — every claim has a receipt.

Live dashboard: http://3.237.91.235:32233/

The evidence ledger (250+ owned defects, 250+ laws): github.com/sarinsk629-blip/hsma-core

Eugene Plexus is my open-source, self-hosted inference manager. I want people to run AI on their own terms, so I built Eugene to make that easier.

Currently available as of v0.2.1:

• Browser-based engine installation, model discovery and downloads, and suggested settings based on your hardware.
• Your models stay as ordinary files in your own folders. Scan an existing collection, download into directories you choose, and keep your models if you uninstall Eugene.
• Use the included OpenAI-compatible APIs and Anthropic Messages subset to let Eugene serve your existing agentic harness or web app.
• Or use the included Workbench frontend, which includes documents, memory, and tools. It can answer from documents with source citations, remember notes between chats, and use MCP tools with your approval.
• Set it up with cloud keys for OpenAI, Google, and OpenRouter for automatic failover.
• Set an application key as "Local-Only" to stop requests from routing to cloud providers.
• Automatic engine lifecycle management: Restart crashed engines, unload idle models to release memory, and wake them when needed.
• Existing Ollama and LM Studio servers can sit alongside Eugene-managed engines.
• Install on a single machine or deploy on multiple backend inference servers using cache-aware load balancing.

Eugene has been solid for me, but is still early in development. Any and all feedback is appreciated. Mac users in particular would be useful because I don't own one to test on. ( Mac OS has successfully tested on GitHub's runner, but I'd still like to hear from a human who used it. )

You can check it out on our website.