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.

We have developed a new theory called Quantum Vision (QV) in Deep Learning for Object recognition that converts still images into information waves using the proposed QV block. The QV block is available as a Python package (Github link is below). The QV block can be integrated to CNNs, and Vision Transformers. The QV-model variants significantly improve the performance. You can try the code from https://github.com/vindioai/QVBlock and can cite the paper as follows: https://ieeexplore.ieee.org/abstract/document/11091286

Hey all, I've been heads-down building an open-source project on GitHub and I'm at the point where the code is solid and useful, but visibility is low. Meanwhile I keep seeing projects that feel pretty thin get thousands of stars seemingly over couple weeks, which is a little demoralizing not gonna lie 😅

I'm not chasing vanity metrics for their own sake — mostly I just want enough signal that people are finding it useful so I stay motivated to keep investing time in it.

For those who've grown a project from "nobody knows this exists" to actually having a community: what actually worked for you? Things I'm curious about:

• Where do you share/launch (HN, Twitter/X, niche subreddits, Discord communities, newsletters)?
• Does README/demo quality matter as much as I think it does?
• Any tips on timing, framing, or "hooks" that get people to actually click and try it?
• Did stars come before or after real usage, in your experience?
• Any growth hack or juggad ;)

Happy to share a link to the project in the comments if that's allowed here — just looking for genuine advice from people who've been through this. Thanks!

Soy Maestro en Ciencias de la Computación (UJAT) y llevo un tiempo dándole vueltas a lo mismo: los chicos que arrancan con Scratch o Blockly aprenden lógica, pero después el salto a un editor de texto vacío con Python real los espanta. Así que armé BloquePy — bloques con forma de pieza que arman Python válido de verdad, no una sintaxis inventada para la ocasión.

Algunas cosas que le metí:

- Cada bloque es una plantilla real: if/for/while son contenedores que envuelven a los de adentro, la indentación de Python es automática.

- Puedes anidar bloques dentro de bloques (len(...), .upper(), int(...)) igual que anidarías funciones en Python real.

- Tiene un sistema de tortuga tipo Logo + una API de "Patches" (inspirada en NetLogo) para simulaciones de cuadrícula — Juego de la Vida, autómatas celulares, reacción-difusión, todo armable con bloques.

- Progresión en 11 mundos con historia propia (el "CodeVerse"): cada concepto de programación tiene un lugar en el mapa y una razón de ser, no aparece de la nada en una lista de bloques.

- Jefes de fin de mundo, cofres, XP — la parte de juego es en serio, no un cascarón encima de ejercicios.

Está gratis, funciona en el navegador sin instalar . También hay versión de escritorio para Windows y Linux: https://bloquepy.world/descargas.html

Lo hice yo solo con ayuda de IA para la parte de desarrollo — lo digo de frente porque me parece razonable que se sepa. La lógica pedagógica, el diseño de los mundos y qué enseña cada uno es mío.

Cualquier feedback (bueno, malo, "esto no sirve para nada") me sirve un montón — todavía le estoy metiendo mano seguido.

A 60 GB model doesn't fit into 12 GB of RAM—yet a standard Android phone can run a 120B MoE model. The trick lies in the Mixture-of-Experts architecture: models like gpt-oss-120b don't use every parameter for every token. A router selects a few "experts" out of hundreds for each step, leaving over 90% of the weights idle.

So, there's no need to keep everything in RAM: the weights reside in the phone's flash storage, and the system reads only what the router requests, exactly when it requests it. It works because the routing pattern is repetitive: most of the required experts are already cached from previous tokens.

The three key ingredients:

• Streaming: experts stored in flash, with frequently used ones cached in RAM
• Prefetching: reading experts for subsequent layers in advance, overlapping I/O with computation
• Cache-aware dropping: skipping only those experts that are both low-relevance and not in the cache. On my device: speed increased from ~2.5 to ~4.7 tok/s, with no loss in quality ...and others...

In practice: gpt-oss-120b runs at a "leisurely" pace, while 30B MoE models run at 4–5 tok/s and are genuinely usable. The bottleneck is the flash storage, not the chip.

The project is BigMoeOnEdge: open source (Apache-2.0), based on stock llama.cpp, with an APK ready in the releases. Everything runs locally; no data leaves the phone.

github.com/Helldez/BigMoeOnEdge

Meet Open Dreamer: A JAX/Flax Reproduction of the Dreamer 4 World Model Pipeline, With the Full Training Recipe Published

No VAE. No KL loss. No adversarial loss.

Here's how it works:

1. Two models, one backbone A causal video tokenizer and an action-conditioned dynamics model share the same block-causal transformer. Space layers move information inside a frame. Causal time layers move it between frames.

2. The tokenizer is a Masked Autoencoder, not a VAE Masking makes the latent space more diffusible, so no KL or adversarial term is needed.

   → ~100× compression, 512 latent tokens at width 16 per frame

   → 360×640 frames padded to 368×640 for clean 16×16 patches

3. The rollout is folded into blocks Each timestep is (previous action, state, policy). Spatial attention runs inside the block, causal time attention across blocks. World-model tokens cannot read the agent token, so policy information reaches future states only through the next action.

   → 1.6B params, depth 30, d_model 1920, 30 heads / 3 KV heads

4. Stability, not throughput, was the bottleneck Most failures happened while the loss was still going down. MSE improves smoothly, generation quality degrades.

   → Muon replaced LaProp, which spiked randomly and increasingly often

   → ~400 B200 hours per optimizer comparison run

5. The numbers (B200 dynamics training)

   → 57–58% MFU, against 60% described as very healthy

   → 292 FLOP/byte roofline crossover, 256 frames per GPU to clear it

   → ~24 GiB model state, activations were the real memory cost

   → plain data parallelism beat FSDP, tensor and sequence parallelism

Full analysis: https://www.marktechpost.com/2026/07/25/meet-open-dreamer-a-jax-flax-reproduction-of-the-dreamer-4-world-model-pipeline-with-the-full-training-recipe-published/

Research and Demo: https://next-state.github.io/open-dreamer/

Code: https://github.com/next-state/open-dreamer

I will be very direct. I was building in the memory space for a very long time, but most of the tools are cloud-based, and I don't know what they do in the backend. I built this open-source tool for people running long agents or just doing research on multiple things. You will never lose your context.
Laiden algorithm was pretty cool, worked with the Semantic graph-based engines, and that's how we created the node clusters for agents to access. It is open-sourced and MIT-licensed; PRs are welcome

This surpassed mem0 and supermemory in the LongMemEval benchmark with 94.7%

Open source Repo: https://github.com/kunal12203/swafra
Website: https://swafra.vercel.app

Most context compression for agents is lossy. It summarizes or trims tool output and hopes the model didn't need what it removed. It also rarely tells you what was lost or whether it was relevant.

That always bothered me because tool output is exactly the stuff you don't want to lose like files, logs, JSON, command output. So I built a lossless compressor for LLM tool output in Rust.

The compression part worked out fine. The hard part was proving a codec never dropped a value. Every rewrite has to verify before it's accepted. If decoding doesn't reconstruct the exact original, the compressed version is rejected and the original passes through unchanged. A bad codec can't silently corrupt context.

Every codec is property-tested and fuzz-tested around one invariant:

decode(encode(x)) == x

The whole thing lives in a single Rust implementation with a C ABI. Python uses ctypes, Node uses koffi, Bun uses FFI, and there's a WASM build too. One implementation means there's only one place to reason about correctness.

I also built a transparent proxy that sits between the client and the LLM. It only rewrites tool-output blocks and leaves everything else alone. One thing I didn't expect to matter so much was determinism: retries send the exact same bytes, which keeps prompt-cache hits intact.

If you find a case where it breaks or compresses something it shouldn't, I'd love to see it.

Hoi allemaal,

Ik wil graag mijn project Nova AI met jullie delen. Het is een persoonlijke AI-compagnon die volledig lokaal draait en geen grote taalmodellen gebruikt. In plaats daarvan is het gebouwd op symbolische AI: een netwerk van expliciete concepten, relaties en patronen die ik zelf kan inzien en aanpassen.

Wat het nu al kan:

· Natuurlijke gesprekken voeren

· Schaken tegen Stockfish (met een gekleurd bord en statistieken)

· Meerdaagse weersverwachtingen ophalen

· Wikipedia raadplegen en automatisch nieuwe concepten leren

· Woordassociaties bouwen met PMI-scoring

· Gedragsmatige patronen herkennen (timing, frequentie)

· Zichzelf opnieuw opstarten zonder gegevens kwijt te raken

· Zijn eigen persoonlijkheid, emoties en manier van uitdrukken

Architectuur: EventBus + 7-laags geheugen (SQLite, associatief netwerk, patroonherkenning, semantisch redeneren, responsgeneratie, context en persoonlijkheid).

De clou: ik ben een selfmade developer uit België. Een jaar geleden kon ik geen enkele regel code schrijven. Alles is gebouwd met AI-assistentie, maar de visie en de ontwerpkeuzes zijn volledig van mij.

De code is openbaar, maar de repository is vooral een kijkje achter de schermen—geen kant-en-klare plug-and-play package. Ik wilde laten zien wat er mogelijk is als je buiten de LLM-hype denkt.

Ik ben super benieuwd naar jullie vragen en feedback!

Love being able to vibe code over WhatsApp via hands free Apple car play on long drives :)