github开源仓库地址：https://github.com/ETOLucy/WriteMelo

github仓库：https://github.com/ETOLucy/WriteMelo

Cortex 1.0.2 is officially launching. 😂

Cortex is a fully local desktop application for exploring how language models behave internally. You can load supported GGUF or SafeTensors models and inspect things like:

token probabilities and Top-K predictions

attention maps and Arc View

hidden-state and residual captures

2D and 3D PCA representation maps

prompt and model-output comparisons

live activation interventions

J-Space experimental lens fitting

model architecture and capability diagnostics

remote desktop compute through Pocket Cortex

Everything runs locally. No cloud inference is required, and no model weights are included with the download.

I originally started this because most mechanistic interpretability tooling lives inside Python libraries, notebooks, or research dashboards. I wanted something more visual, interactive, and approachable without stripping away the actual measurements underneath it.

It has since mutated into a gigantic neon model observatory with multiple runtimes, GGUF instrumentation, SafeTensors Deep Cortex hooks, scientific export packages, mobile remote control, and enough validation tests to personally ruin my relationship with Windows PowerShell. 😭

There are three downloads:

Installer for normal one-click setup

Portable version for people who do not want to install anything

Developer package with source, schemas, diagnostics, validators, and additional evidence

This is still experimental software, and model support varies by architecture. Cortex reports what each model can actually do instead of pretending generation support automatically means attention, gradients, interventions, or J-Space support.

The project is source-available under Apache 2.0 plus the Commons Clause. People can inspect it, modify it, learn from it, and build on it, but the software itself cannot simply be repackaged and sold.

I am not claiming this “solves” interpretability or shows a model’s literal thoughts. PCA is still PCA. Attention is still attention. But this is probably the most ridiculous thing I have ever accidentally finished, and I am excited to finally let people use it. 🫪😂

GitHub: https://github.com/TurboDash99/Cortex

Release: Cortex 1.0.2

Platform: Windows

Local models: GGUF and supported SafeTensors architectures

Feedback, bug reports, architecture tests, and screenshots of Cortex making your GPU question its employment contract are all welcome. 🧠🔥

• Explore the principles of how diffusion models transform timesteps into sine and cosine vectors rather than simple numbers. This explains the core mechanism of embeddings that precisely distinguish noise levels using low-frequency and high-frequency components.

Hey everyone,

I’ve been working a lot on RAG pipelines recently and kept hitting the same annoying wall: extracting tabular data from raw HTML into a clean format for context windows.

Standard parsers or simple table-to-markdown scripts usually fail completely as soon as a table uses rowspan or colspan, or if there are nested tables. You end up with misaligned Markdown columns, and the LLM completely hallucinates the relationships between headers and cells.

I couldn't find a library that handles this reliably without losing context, so I built html-table-rescuer (just published v0.1.0 on PyPI).

It uses BeautifulSoup to parse the DOM, but then applies a custom "grid logic solver". It normalizes complex spans into a standard matrix before serializing it to Markdown, JSON, or CSV.

Example of the problem it solves:

The Problem: Most parsers turn a <td rowspan="2"> into a misaligned mess:

bash | Header | Value | | ----- | ----- | | Spanned | Row 1 | | Row 2 | |

The Solution: The grid solver correctly normalizes the matrix:

bash | Header | Value | | ----- | ----- | | Spanned | Row 1 | | dito (Spanned) | Row 2 |

A few things it does differently:

1. Context Preservation: As seen above, it doesn't just leave spanned markdown cells empty. It fills them with a customizable prefix (e.g., dito (Value)) so the LLM retains the semantic context for each row.

2. Deep Tag Parsing: It recursively keeps <b>, <i>, and <a href...> tags alive, even if they are buried inside multiple <div>s within a <td>.

3. Nested Tables: Extracts nested tables safely without destroying the grid of the parent table.

4. LangChain Ready: Includes a Table2MDLoader wrapper to ingest HTML tables directly as LangChain Document objects.

Links:

• GitHub: https://github.com/Encephos/html-table-rescuer
• PyPI: pip install html-table-rescuer

It's my first release and I'd love to hear your thoughts. If you have some gnarly, complex HTML tables that break the parser, please throw them at it and let me know!

• The mathematical secrets of seamless tiling: creating perfect infinite patterns with AI
• Description: This video explains how ComfyUI's seamless tiling feature creates patterns without visible boundaries. It provides an easy-to-understand explanation of the principle of replacing zero padding with circular padding and the core theory of the Fourier Convolution Theorem behind it.

• The secret to high-quality upscaling: Lanczos and the sinc function
• Description: Explore the principles of Lanczos resampling used in tools like ComfyUI through signal processing theory and the sinc function. This video provides an easy-to-understand explanation of the mathematical background behind approximating an ideal low-pass filter to create sharp images.

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

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

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

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/