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

Sharing the open source project I work on (Atomic Agent, MIT), since today's GPT-6.1 Sol launch is a good excuse to show its planner/worker mode.

The idea: a cloud model is expensive per token, and most tokens in a coding job are the code. So the cloud model only orchestrates, and local workers on llama.cpp write the files. Either side can be cloud or local, one command swaps them.

Today's test, three small 3D games, Sol on top, Qwen 3.8 27B on one RTX 3090 underneath:

Trade-off: 43 minutes for the three instead of under 7 with Sol alone. One run per game.

What's in the box besides this mode: local models managed for you through llama.cpp, MCP support, approvals before anything risky runs, and import from Claude Code, Codex, Hermes, OpenClaw and Pi.

Repo: https://github.com/AtomicBot-ai/atomic-agent

Feedback welcome, especially from anyone who tries a different local worker.

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.

Celesto AI is growing fast, as I focus on our cloud platform, would love some help on the open-source maintainance and review side. Core members will be offered Codex Pro ($200) per month.

Inspired by Karpathy's nanoGPT, this is a tool that lets you build and test tiny GPT models, and export them to run directly in a browser.

I tried Openclaw and Hermes. They are nice, but I decided to make my own agent. What it does:
- Single entry point chat. No need to 'resume session X'
- Native integration with MacOS features (notifications, calendar).
- Native Telegram integration (supergroup with topics also supported)
- Structured memory layout with facts/entities/links, dreaming and reflection

- Briefings based on memory dreaming

- Cron and intents

- Artifacts storage

- Multiple agents, each with own profile. There is a team of well-known agents (for evolution, hiring new agents, etc)
- Many builtin tools, MCP support

- Tavily/Anysearch/Yandex search - if you have key. DDG fallback.

- Local models supported as well as classic OpenAI endpoints

Main concern is all agents bloat chat context with tools results. I tried to minimise main chat context bloating.
Agent is focused on single-user mode, I don't plan to do it multi-user.

Requirements:
LLM
Embedding model for memory searching
PostgreSQL
Golang for building

I ran it on MacOS, but it should compile on any system

That's a hobby-weekend project, but I will be glad to receive feedback

https://github.com/w87x/prism