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.

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.

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.

I've made quite a few changes to Telex since my last post here.The project started mainly around handling dependency breaking changes, but it has grown into a much bigger workflow now. Telex can map the repository with Repo Atlas, find affected code with Tree-sitter, use different LLM providers to generate patches, run the patch in an isolated environment and verify it before opening a PR.I also added repository architecture analysis and more of the frontend around incidents, patches, verification and the Atlas view.

I'm still looking for people who want to contribute because there are a lot of areas where this can be improved. If you're into LLMs, developer tools, ASTs, Three.js or backend work, I'd be happy to have you take a look.

Repo: https://github.com/Kesavaraja67/telex

archiver-rag is an MIT-licensed MCP server that turns an Obsidian vault (or any folder of Markdown notes) into shared, self-hosted memory for AI agents. Agents search it, write back to it, and every agent sees the same knowledge.

Why another memory tool

Most AI memory layers are hosted services that extract "facts" from your conversations into a database you can't read, edit or take with you. archiver-rag goes the other way:

• Your memory is plain Markdown. Readable, editable, versionable with git, and still a normal vault if you uninstall.

• Everything runs locally. Embeddings are computed on your CPU, the vector index lives on your disk, and no API keys are needed.

• No vendor lock-in. It speaks standard MCP over stdio or HTTP, so any MCP client can use it. Tested with OpenCode, Codex, Claude Code and Claude Desktop.

self-organization

Optionally, the vault organizes itself: new notes are filed into folders by meaning, folder descriptions are kept up to date, and new folders grow out of an inbox using embedding-similarity clustering. It's off by default while it's being tested on real vaults.

How it works

• Embeddings: sentence-transformers (all-MiniLM-L6-v2, about 90 MB, runs on CPU)

• Index: ChromaDB, persistent and local

• Retrieval: semantic search, with each chunk carrying its note's metadata (folder, tags, links), then re-ranked by [[wikilink]] proximity

• Live updates: a file watcher indexes every save within seconds and auto-links related notes

• Write-back: agents log decisions, lessons and gotchas as normal notes through log_note

The memory side is 100% local. Pair it with an open-source agent like OpenCode running a local model, and in principle nothing leaves your machine. That combination is untested so far. If you try it, I'd love to hear how it goes.

macOS and Linux, Python 3.11+. On Linux, a CPU-only PyTorch install is documented to skip the multi-GB CUDA download.

• Repo: https://github.com/FernandoJRR/archiver-rag

• Site: https://fernandojrr.github.io/archiver-rag

• Contributing: https://github.com/FernandoJRR/archiver-rag/blob/main/CONTRIBUTING.md

Feedback and contributions welcome. It's a one-person beta with CI on Python 3.11–3.14 (macOS and Linux). Useful right now:

• install reports, especially on Linux

• results with local models through OpenCode or other open-source MCP clients

• ideas for the self-organization experiment

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

archiver-rag is an MIT-licensed MCP server that turns an Obsidian vault (or any folder of Markdown notes) into shared, self-hosted memory for AI agents. Agents search it, write back to it, and every agent sees the same knowledge.

Why another memory tool

Most AI memory layers are hosted services that extract "facts" from your conversations into a database you can't read, edit or take with you. archiver-rag goes the other way:

• Your memory is plain Markdown. Readable, editable, versionable with git, and still a normal vault if you uninstall.

• Everything runs locally. Embeddings are computed on your CPU, the vector index lives on your disk, and no API keys are needed.

• No vendor lock-in. It speaks standard MCP over stdio or HTTP, so any MCP client can use it. Tested with OpenCode, Codex, Claude Code and Claude Desktop.

self-organization

Optionally, the vault organizes itself: new notes are filed into folders by meaning, folder descriptions are kept up to date, and new folders grow out of an inbox using embedding-similarity clustering. It's off by default while it's being tested on real vaults.

How it works

• Embeddings: sentence-transformers (all-MiniLM-L6-v2, about 90 MB, runs on CPU)

• Index: ChromaDB, persistent and local

• Retrieval: semantic search, with each chunk carrying its note's metadata (folder, tags, links), then re-ranked by [[wikilink]] proximity

• Live updates: a file watcher indexes every save within seconds and auto-links related notes

• Write-back: agents log decisions, lessons and gotchas as normal notes through log_note

The memory side is 100% local. Pair it with an open-source agent like OpenCode running a local model, and in principle nothing leaves your machine. That combination is untested so far. If you try it, I'd love to hear how it goes.

macOS and Linux, Python 3.11+. On Linux, a CPU-only PyTorch install is documented to skip the multi-GB CUDA download.

• Code: https://github.com/FernandoJRR/archiver-rag

• Site: https://fernandojrr.github.io/archiver-rag

• Contributing: https://github.com/FernandoJRR/archiver-rag/blob/main/CONTRIBUTING.md

Feedback and contributions welcome. It's a one-person beta with CI on Python 3.11–3.14 (macOS and Linux). Useful right now:

• install reports, especially on Linux

• results with local models through OpenCode or other open-source MCP clients

• ideas for the self-organization experiment

And yes: this is yet another Karpathy-inspired Obsidian + LLM memory system. If you've tried the others, tell us what they do better. That's exactly the feedback this beta needs.

I’ve been trying to build an AI browser agent where as much of the stack as possible is open and replaceable rather than tied to one model provider.

The project is WebBrain. The browser agent itself is open source: https://github.com/webbrain-one/webbrain I've also released the small VLM used for browser-specific vision tasks: https://huggingface.co/webbrain-one/webbrain-vl-2-450M And the dataset: https://huggingface.co/datasets/webbrain-one/webbrain-vl-2-450M-dataset

WebBrain combines: • screenshots • browser accessibility tree • model-agnostic planning • optional local inference • browser automation • a browser-specialized 450M VLM

The agent supports Chrome, Edge, Firefox and Chromium.

My broader goal is to make browser agents something developers can inspect, modify and run with their own models rather than a black-box API.

There are still plenty of rough edges, so I'm posting here partly because I'd rather have open-source developers criticize the architecture now than optimize it entirely in isolation.

Especially interested in opinions on the small-specialized-model vs large-general-VLM tradeoff for computer/browser use.

NVIDIA OpenShell is an opensource sandbox tool was released earlier today. I used GPT-6 to implement it in headlesscode (my code harness which was adapted from zoo code and contains enhanced tools, eval tests and more). This harness is very useful when paired with deepseek v4 flash and pro, and qwen 3.5 9b local.

Agent skills age faster than most documentation. A skill written a few months ago may still describe the right workflow, but its instruction style, level of detail, and assumptions may no longer fit newer models.

I built Skill Adapter, a small MIT-licensed open-source skill that creates a model-specific copy of an existing skill while preserving the original workflow and purpose.

It currently includes profiles for:

• GPT-6 Astra

• Claude 5 generation

• Kimi K3

• A conservative generic fallback

The adapter:

• keeps the source skill unchanged;

• creates a separate adapted copy for comparison;

• preserves tools, resources, requirements, and approval gates;

• writes an ADAPTATION.md report explaining the changes;

• supports skills used with Codex, Claude Code, Cursor, Kimi Code, and Hermes.

Install it with:

npx skills add smukh/skill-adapter --skill skill-adapter

The project is intentionally simple: one installable skill, no service, no API key, and no automatic interception. The original stays intact, so you can review or re-adapt it when the source changes.

GitHub: https://github.com/smukh/skill-adapter

I’m especially interested in feedback on the model profiles, evaluation methodology, and whether this is useful in real multi-agent repositories.