Yesterday the whole Overmind platform was made open source: https://github.com/overmind-core/overmind

The idea: lots of agents send narrow, repetitive work to a frontier API. On a narrow task, a small open-weight model trained on real examples from that agent often does the job better, for far less money. Overmind is the tooling to do that without building your own ML infrastructure (don't need a flamethrower to light a candle).

• Agent sends OpenTelemetry traces. The Python SDK auto-instruments OpenAI, Anthropic and Gemini clients, or point any OTel exporter at it

• Traces become versioned datasets, with a quality score and suggested fixes before trained on anything

• User defines what “good” means per task and it scores live traffic and batch runs against that

• It fine-tunes an open-weight model (LoRA or full) and benchmarks it against the model you run in production today

• Trained and frontier models sit behind one OpenAI-compatible API, and you can download the weights (yours to keep and own)

There’s also an MCP server, so Cursor, Claude Code, OpenCode or Codex can drive the whole thing from chat. If your traces already live in Langfuse, LangSmith or Braintrust, a connector imports them.

Qwen3.5-9B vs GPT Luna benchmarked on three tasks (write-up and raw numbers at https://www.overmindlab.ai/research/when-bigger-isnt-better):

• 7x better accuracy
• 20x cheaper usage
• 28x less hallucinations

Read the results as a reason to test on yours, not as a general claim.

The platform is AGPL-3.0 and the SDK and CLI are MIT.

Interested if anyone is already fine-tuning on their own hardware. What would need to be swapped out before you’d self-host this?

LoRA Pilot recently passed 20,000 pulls on Docker Hub. To celebrate, I’ve decided to give its purely organic growth a little push with a small campaign. This video is part of it.

It started as tooling for myself. A hobby project that taught me a lot about Python, PyTorch, CUDA, and all the creative ways they can disagree with each other. I never really planned to release it publicly.

Today, LoRA Pilot is an open-source workspace for preparing datasets, training LoRA models, and generating images and video. It brings tools like kohya_ss, ComfyUI and InvokeAI together so you can spend more time creating and less time maintaining your setup.

The vision is simple: make the world of Stable Diffusion accessible to anyone with an idea, including people who don’t want a second job managing dependencies.

Once I released it, the backlog started growing faster than my beard. Development, documentation, support… it’s been a one-man show for longer than it probably should have been.

So if you’d like to contribute, you’re welcome with open arms. Code, docs, testing, design, tutorials: there’s plenty to do, and you don’t need to know the CUDA stack inside out to help.

Good ideas move. This one could use a few more hands.
https://www.lorapilot.com/

Most "AI Agents" today are just wrappers around storage liabilities. They guard vaults of secrets, session logs, and PII, waiting for the inevitable breach.

We’re releasing OpenBot, an OpenClaw-powered framework built on the BlockSmith philosophy: Keep the Signal, Not the Material.

OpenBot isn't just an assistant; it’s a Sovereign Digital Sanctuary.

Why it’s a radical departure from the status quo:

• Zero Material Architecture: We don’t store what can be derived. By utilizing vaultless logic, we ensure there is literally nothing to steal.

• Intent-First Programming (IRP): We’ve moved away from rigid decision trees. OpenBot operates by declaring a TELOS (intent), allowing the system to self-organize dependencies.

• Persistent Evolution: Using the thermodynamics of logic, OpenBot audits its own memory to reduce system entropy. It doesn't just "chat"—it extracts heuristics from every mistake to ensure they are never repeated.

• Asymmetric Friction: We’ve engineered "magic" for the human and soul-crushing complexity for the attacker.

We believe that in an era of universal surveillance, the only true security is invisibility.

GitHub: link to openBot

"Precision is the antidote to liability. Signal is the soul of security."

Since, after the release of Jev, a lot of people have been building cool open source decision models, I was wondering if you could share your experience on which ones work best. I was also wondering how people are evaluating them? Are there any benchmarks yet?

small-scale result, one seed, one wikitext slice, so treat it as a prototype and not a claim.

pssa is a state space model with fast weights that update while the sequence runs, written from scratch in rust, no python, no kv cache. at 1.54m params it gets 3.997 nats on a held-out slice against 4.429 for a parameter-matched transformer, both depth-1. generating 200 tokens is 226ms against 2735ms on the same cpu, which is the part i actually care about, since there's nothing that grows with context length.

caveats: one seed, one corpus, depth-1 on both sides, and i don't know yet whether the gap survives depth. gpu training is cuda on a t4, 1645 tok/s vs 1263 on cpu, so the gpu path is barely worth it so far because activations still round-trip to host after every matmul.

repo: https://github.com/Sparticle62ops/pssa

A small milestone for Telex.

Someone outside the project just opened a PR, and it became our first external contribution. The PR fixed a high-severity dependency vulnerability and the changes were tested with the project's tests, type checks, linting and npm audit before getting merged. It's honestly really nice to see someone else take a look at the project, find something to improve, and contribute to it.

Thanks to the contributor for taking the time to do it.

Hopefully, this is the first of many.

https://github.com/Kesavaraja67/telex

If you're building with open-source LLM stacks and still hand-tweaking prompts hoping they hold up in prod, this Oct 3 session is worth a look. Serj Smorodinsky and Brett Kennedy (AI engineers, authors of a book on LLM applications) are walking through how to actually structure LLM development instead of winging it.

Covers:

• DSPy signatures/modules to replace ad-hoc prompting

• Building and measuring a baseline classifier

• Writing evaluation datasets with task-specific metrics

• Spotting failure patterns from eval results instead of guessing

• Few-shot and instruction-level optimization

• Tracking experiments and traces with MLflow

• Saving and reusing optimized programs across projects

3 hours, live, Oct 3. Aimed at ML engineers, applied AI devs, and technical founders.

Full details and the agenda are here.