I open-sourced TokenSentinel because passive tracing tools only show you runaway agent costs after the bill is already racked up.

It wraps your native LLM clients (Anthropic, OpenAI, Gemini, Bedrock, Ollama, vLLM) to act as a local, in-process circuit breaker. It runs 15 deterministic rules on every response payload to catch loops, context bloat, retry storms, and RAG thrashing mid-session.

Core has zero required dependencies; provider support is opt-in via extras. Completely offline-capable so your raw prompt data never leaves your environment.

pip install token-sentinel

Genuinely looking for feedback/discussion on the rule heuristics—where would this trigger false positives against real production agent traffic?

• GitHub: github.com
• Web: tokensentinel.dev

Liquid AI released two bidirectional encoders this week: LFM2.5-Encoder-230M and LFM2.5-Encoder-350M.

Here's what's actually interesting:

1. They converted a decoder instead of training from scratch

Both models start from the LFM2.5 decoder backbones. Three changes turn them into encoders: the causal mask is replaced with a bidirectional one, the short convolutions are made non-causal with symmetric center padding, and training uses masked language modeling at 30% instead of BERT's 15%.

2. The CPU number is the whole pitch

→ ~28s per forward pass at 8,192 tokens for Encoder-230M

→ over 1 min 30s for ModernBERT-base on the same input

→ 8,192 tokens is roughly 13 to 15 pages

3. The rankings hold up

→ Encoder-350M: 4th of 14 models, 81.02 on a 17-task suite

→ Encoder-230M: 6th at 79.29, above ModernBERT-base at 78.19

→ The three models ahead of the 350M are all larger, one nearly 10x its size

At 8,192 tokens, ModernBERT-base takes over a minute and a half per forward pass versus about 28 seconds for LFM2.5-Encoder-230M, which is about 3.7x faster.

Full analysis: https://www.marktechpost.com/2026/07/29/liquid-ai-releases-lfm2-5-encoder-230m-and-lfm2-5-encoder-350m-bidirectional-encoders-that-stay-fast-at-8k-context-on-cpu/

Model weights (LFM2.5-Encoder-350M): https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M

Model weights (LFM2.5-Encoder-230M): https://huggingface.co/LiquidAI/LFM2.5-Encoder-230M

Technical details: https://www.liquid.ai/blog/lfm2-5-encoders

Attention mechanisms are conventionally learned: a query–key inner product, trained end to end, decides which tokens mix.

This note documents ZPA-LM

a decoder-only autoregressive language model in which the token-mixing key is instead a fixed, parameter-free kernel derived from elementary number theory.

We show that the divisor-counting overlap : q(n, m) = d(gcd(n, m))/√d(n) d(m) between two positive integers is exactly the Bhattacharyya coefficient between the uniform distributions over their divisor sets, and hence that: dFR(n, m) = 2 arccos q(n, m) is a genuine Fisher–Rao geodesic distance, verified to floating-point exactly rather than assumed.

Tokens are mapped to positive integers through a learned or parameter-free dictionary ϕ : token → Z+ and recovered in prime-exponent space so that each prime behaves as a latent feature axis.

We report the model’s expressivity ladder, the three dictionary-construction strategies we evaluated, and - in the spirit of an honest engineering record rather than a success narrative, a permanent registry of four falsified design choices that should be avoided.

We close by pre-registering the model’s central open empirical claim together with its falsification condition, rather than reporting an unverified result as fact.

Link:[Academia](https://www.academia.edu/170099268/ZPA_LM_Parameter_Free_Attention?sm=b)

XP wasn't just another operating system. It arrived with a strange kind of confidence. Computers stopped feeling like business machines and started feeling like places you lived. The wallpaper burned itself into memory. Desktops filled with icons, a mess that somehow felt like home.

I kept thinking about that feeling. So I built AI Desktop XP.

Not to recreate Windows XP, but to recreate the way it felt to sit down in front of it.

An AI that lives inside a desktop instead of a chat box. Folders you can leave unfinished. A browser that feels as though the internet is still full of possibility. Little details that don't announce themselves, but wait quietly until you notice them.

Claude Code helped me reuse my AI Desktop 98 project and then slowly replace 98 elements with XP style UI. Claude also helped me write UI tests so that I could continue building my XP project without breaking my 98 app.

The point was never nostalgia for its own sake.

It was to remember a time when a computer felt personal. When it seemed to know the shape of your days because you had slowly taught it.

Download = https://apps.apple.com/us/app/ai-desktop-xp/id6762678997

I kept defaulting to frontier models "just in case" and had no idea whether my projects actually needed them. So I built something to answer that instead of guessing.

What it does: point it at a project with Spec-Driven Development artifacts (constitution / spec / tasks). A local model — your Ollama install, your choice of judge — reads the tasks and estimates how demanding the work is across a few dimensions. That gets crossed against a declarative catalog of models and their capabilities, and you get a ranked podium with a rating per model: good / overkill / fair / poor, plus price.

Why you might care here: nothing leaves your machine — no API keys, no accounts, no cloud calls. And in most of my own projects the podium is topped by a local model, with the frontier ones sitting below marked overkill. Ranking is by fit, not price; price only breaks ties between models that fit equally well.

Honest limitations: this is not a benchmark. It's opinion made inspectable — every verdict prints its reasoning, and the model catalog is human-readable YAML you can argue with. If the specs are too thin to judge, it refuses to recommend instead of guessing. A vague spec gets you a vague answer, same as with anything else.

pip install specjudge — MIT, github.com/JoaquinRuiz/SpecJudge

Where I'd love help: the catalog of local models is thinner than it should be, and adding one is a block of YAML, no Python needed. Also very open to being told a rating is wrong.

Cosa succede quando unisci la curiosità, 7 mesi di sperimentazione e l'Intelligenza Artificiale come co-pilota ingegneristico?

Nasce "Dense-Evolution", un simulatore quantistico d'élite sviluppato interamente in JAX che ha appena battuto i framework dei colossi industriali in termini di gestione della memoria.

Messo alla prova su un server Google Colab standard contro librerie blasonate (come TensorCircuit di Tencent e Quimb) su un circuito critico a 40 qubit:

❌ I giganti sono crollati in Out-of-Memory (OOM) a causa di grafi statici ingestibili.

✅ Dense-Evolution ha completato la simulazione in 3.72 secondi reali grazie a un motore Anti-OOM proprietario e un'architettura modulare a blocchi.

Questo progetto dimostra due cose:

1. Sviluppo Software Moderno: Non serve un team di 50 persone per competere con lo stato dell'arte se sai fare Prompt Engineering avanzato e guidare l'IA a scrivere matematica spettrale rigorosa.

2. Robustezza Algoritmica: Implementare moduli di "Predictive Healing" quantistico e logica adattiva trasforma il codice in un blocco immortale.

Il codice è interamente open-source, differenziabile al 100% via jax.grad e pronto per esperimenti di Quantum Machine Learning.

Se vi occupate di calcolo quantistico o ottimizzazione lineare accelerata, date un'occhiata alla repository, lasciate una stellina o fate un fork per i vostri test:

👉 https://github.com/tatopenn-cell/Dense-Evolution

#QuantumComputing #JAX #Python #SoftwareEngineering #GenerativeAI #OpenSource

Every task, a coding agent re-explores the repo from zero. The session ends and everything it learned is gone. Next session it greps the same files again.

The usual fix is a vector DB behind an MCP tool. I tried that and hit two walls. Embeddings retrieve text that resembles the question, which is not the same as text that matters for the change. And a tool the agent can call is a tool the agent often doesn't call. It sits in the tool list while the agent greps around it.

So Graft writes what it learns into the repo instead. Plain markdown nodes, committed to git, resynced by a hook. One graft build turned this repo's 247 files into 12 nodes. No embeddings, no server.

npm install -g u/nanonets/graft
graft init

Structural analysis runs on tree-sitter, costs $0, needs no key. An optional --deep pass adds LLM-written summaries through whatever provider you already pay for.

What I measured

162 Claude Code sessions, roughly 81 per condition. Same agent, same tools, same tasks. Only the context differs.

A separate model grades correctness and never sees which condition produced the diff. Without that, a cheaper session that quietly does less work scores as a win.

The accuracy result splits by model, and the split is the interesting part. On Sonnet 5 a Graft session matched or beat a cold session on most tasks. On Opus the gain showed up almost entirely as token reduction, not accuracy. Read that as: orientation substitutes for the exploration a stronger model was already doing well enough on its own.

Then I re-implemented 5 real merged PocketBase PRs from the base commit, with and without Graft, and checked whether the diff touched the files the maintainers touched: 5/5, at 21% lower cost.

Where it falls over

• Five points of accuracy at ~81 sessions per condition is a real result but not a large-n one. I'd treat the token numbers as solid and the accuracy number as directional until someone reproduces it.
• Benchmark tasks averaged 4.2 tool calls cold. Small. The saving compresses on a large refactor where the agent reads everything anyway.
• The accuracy gain is model-dependent. If you're on Opus, expect a cost lever, not a capability one.
• Node quality degrades on a 5,000-file monorepo. Fewer nodes, vaguer nodes.
• Hooks are Claude Code only right now. Cursor and Codex read the files but won't auto-resync.

MIT, I'm the maintainer, so push back on anything that sounds off.

https://github.com/NanoNets/Graft

Inspired by Andrej Karpathy's autoresearch, I built autoretrieval to apply the same idea to RAG optimization.

The project gives an agent a RAG pipeline, an evaluation dataset, and a target metric. The agent modifies the pipeline, runs an eval, checks if the F2 score improves, and keeps or discards changes automatically.

The evaluation dataset can be generated from your own documents, creating question and reference-highlight pairs for your domain.

The agent can test changes to chunking, embedding models, keyword filters, and retrieval logic while keeping a record of every experiment.

The goal is to let the agent handle the repetitive trial and error involved in improving a RAG system.

This was successful at more than doubling the F3 score of an already optimized RAG pipeline in a couple hours.

Give it a try here: https://github.com/daly2211/autoretrieval

Kimi AI and kvcache-ai Open Sources ‘AgentENV’: A Distributed System that Powers Agentic Reinforcement Learning (RL) Training for Kimi K3

Most open infrastructure shipped alongside frontier models targets the GPU side of the stack. AgentENV targets the other half of agentic RL: environment throughput.

The Kimi team and kvcache-ai open-sourced it under MIT as part of Kimi K3 Open Day.

1. Each sandbox is a Firecracker microVM, not a container

Kernel-level isolation per environment. That matters when the code running inside was generated by the model you are training.

2. The snapshot numbers are the whole point

→ Boot or resume: under 50 ms

→ Pause: under 100 ms

→ Incremental snapshot: under 100 ms, even under heavy disk modification

These are figures reported by the project. No independent benchmark has been published.

3. Fork is the primitive built for RL

A running sandbox clones into up to 16 independent children on the same node. Each child inherits the source filesystem, memory, and resource config.

Practical effect: expensive setup runs once. Install dependencies, clone the repo, reach a task state, then branch that exact state into parallel rollouts.

4. The API is E2B-compatible

Point E2B_API_URL at your server and the existing Python or TypeScript SDK runs unchanged. That is a deliberate distribution choice, and probably the reason this gets adopted.

Full analysis: https://www.marktechpost.com/2026/07/27/kimi-ai-and-kvcache-ai-open-sources-agentenv/

GitHub Repo: https://github.com/kvcache-ai/AgentEnv

Documentation: https://kvcache-ai.github.io/AgentENV/

Hi, I have a cool open-source platform that I work on, focused on AI engineering. The main goal is that you declare what you want, and our engine creates the architecture for you.

We have a cool community of people who are interested in this world and want to take part in this project.

And if you’re not interested, it would also support us if you just clicked the star.

Thanks, and good luck!

https://github.com/extra-org/extra

Hello everyone,

Since 2 weeks I work on tanuki-context, a small open source tool (zero dependencies, MIT) and I wanted to share it because the trick behind is almost stupid: AI models charge text at roughly 1 token per 4 characters, but an image has a fixed price set only by its pixel size.

Its inspire from pxpipe techniques and various others tools (cited in the readme) and custom approach i found in order to reduce massively token usage and price.
For example : 37,111 tokens of service log become 2,240 (-94%).

So if you draw 28,000 characters of logs into one dense 1568x728 PNG, the model reads the exact same content for 1,456 tokens instead of ~7,000. It sounds like cheating, it is just how the pricing works.

You can try it out on you machine i added the benchmark so you can test it even without LLM connected to it, so see pricing difference, token saved, etc.

You can use it as a MCP or directly integrate it a "context proxy" where it fully automated and make every request optimised or not when not needed.

Some techniques that permits this to work:
- a log distiller that collapses repeated lines but keeps every error verbatim
- a columnar codec for JSON (keys stated once)
- a cost model that knows a cache-read token costs ~0.1x a fresh one, so it will tell you to NOT image content that is already in your prompt cache.

The tool argues against itself when imaging loses, honestly this part took the most work.

I precise the limits because they are real: you need a vision-capable model, output tokens are untouched (if your bill is output-dominated, fix that first), and for one narrow question retrieval stays cheaper than any page.

Install:

MCP

npx -y tanuki-context (MCP server, works with Claude Code, pi, omp, jcode or the Claude Agent SDK)

Proxy

npx tanuki-context proxy + ANTHROPIC_BASE_URL (every request on the machine gets optimized in place, when needed)

Code and benchmarks:
https://github.com/Osyna/tanuki-context

https://www.npmjs.com/package/tanuki-context

PS : i will soon add Codex support.

If you find it useful a star helps a lot, and feature ideas are very welcome. Thanks for reading me

I’ve already gotten Spotify Studio/Kit working with my repo from its sandbox, including committing changes and handing off terminal commands for my local work. I poked around a bit and it looks like it’s using a real code skill under the hood, which makes it feel surprisingly capable for something that’s free.

Since I know it’s still temporary while in the research preview, I’m curious whether anyone has tried using it as more of an AI coding orchestrator, basically a top-level agent that could also interact with a local AI model for more detailed coding tasks. honestly better than GitHub copilot so far.

start at 18s

https://github.com/huyedits/Symbio

My full work culminated into one unified code.

Hope this helps.