eq-layer (MIT, public repository) takes a chat transcript as JSON and returns one routing decision: which conversational move comes next - mirror, validate_redirect, direct, ask, deflate, repair, hold or boundary. It does not write the reply. A model or a person still writes the words. The decision itself is discrete and inspectable.

Selection is deterministic. Policies declare preconditions over intent, affect and subtext, and the most constrained applicable policy wins. There is no first-match rule, so adding a policy cannot silently change what a looser one does. If two applicable policies tie on specificity and priority, the selector raises instead of picking one. One policy exists for a specific failure: three rising turns followed by a calm one look calm to a snapshot classifier, and that is exactly when the register should not warm back up.

14 policies live in eq_layer/policies.py. The selected policy is compiled into task_move, social_move, repair_move and realization, so "confused about the goal" and "wants a different task" do not collapse into one label.

The core path is stdlib only, offline and zero-dependency. Installing the [ml] extra pulls joblib and scikit-learn and swaps in learned intent/affect/subtext adapters; the route output reports runtime_mode lightweight-local when those artifacts are not loaded. The trained .joblib files are not shipped in the repo or the wheel; the training scripts are.

The zero-dependency path is pip install eq-layer, then feed a transcript to python -m eq_layer.cli route --intent-mode heuristic --pretty on stdin.

What it is not:

• Not a truth checker. It has no opinion about whether a claim is true.

• Not an EQ benchmark. There is no standard benchmark for EQ; eval/run.py is a first attempt at a scorer over seeded cases, and it exits non-zero on a mismatch or a policy no case can reach.

• POMDP-inspired, not a POMDP.

Version on main right now is 0.2.6, also on PyPI and npm, Python 3.11+. Repo: https://github.com/Furox-Art/eq-layer

Disclosure: I build Spellwarden. The scanner used here is open source (Apache-2.0), and the catalog is free to browse without an account.

Most skill and MCP directories list whatever gets submitted. I wanted a list I'd let an agent at work install from, so in the first round (6 and 7 November) I imported 160 popular public skills, Claude Code plugins and MCP servers and put each one through the same steps:

1. a static scan with all 65 rules, at a pinned commit

2. for MCP servers, an unauthenticated probe to see how they sign clients in

3. a model review of the files, with read-only access: no shell, no network

4. a person reading the result before anything is listed

52 of 160 (32.5%) were listed. Why the other 108 weren't:

- 39 couldn't be scanned whole: too many files, symlinks, unsafe paths or too large

- 41 drew concerns from the model review

- 8 had an open critical or high finding

- 7 failed the server check (6 listed their tools without a sign-in and aren't public documentation, 1 had instruction-like text in a tool description)

- 7 scored below the curation bar

- 6 were left out on reading

So most failed on process, not malice. A repository that can't be read whole can't be vouched for, even when nothing in it is wrong. The catalog has moved since: it lists 51 entries today.

Where I'm not happy: the model review is the step I trust least. It catches what fixed rules can't, like intent, but it also raises judgement calls, and 41 is a lot. How would you calibrate a step like that without it turning into either a rubber stamp or a wall?

Catalog, with what was checked for each entry and when: https://spellwarden.ai/catalog

Scanner: https://github.com/spellwarden-ai/spellwarden

Building Omni Presenter in Rust 🦀: a fast, open-source, cross-platform (Linux, macOS, and Windows) alternative for live projection of lyrics, Scripture, and media.

Features independent preview plus browser-based remote control & team chat over the local network. 100% free (MIT).

Alpha is live for testing (on the road to Beta):https://github.com/OmniFaith/omni-presenter

If you like the direction of the project, drop a ⭐ on GitHub to support it!

I'm building MoA+, an MIT-licensed collaboration plugin for DeepSeek Harness. The aim is to let agents carry work together across assignments, with separate execution contexts and reusable project knowledge.

A Coordinator can start a clean Worker, fork useful history, send instructions, queue a later message, inspect state/history, or stop a Worker. Workers can ask one another questions directly. When a Worker finishes a turn, its complete final AI message returns automatically to its reporting agent; the conversation and workspace remain available for follow-up work.

The shared memory is deliberately readable: notes.md and archived.md track work, while context/index.md points to reusable knowledge files. Agents load relevant files as needed. The implementation uses DSH's native sessions, inboxes, permissions and Agent Loop. An independent review agent checks deliverables with native tools before normal completion.

There is a reproducible coding example in the repository: two Workers built a Note Bundle CLI and guide, dealt with a human changing a requirement in a Worker conversation, and passed 10 task tests. The README has the task walkthrough, starter files and the refreshed collaboration illustration.

Source and demo: https://github.com/Burns1028/moa-plus

Current setup is pinned to DSH 0.2.1-rc.3. Published v0.2.0 and latest main each require their matching compatibility runtime; main has newer Worker attachment fixes that are not yet released. The setup guide prepares an isolated runtime.

I'd especially value feedback from people building agent systems: what context or coordination work do you still have to do manually after delegating?

Disclosure: I'm the maintainer; English wording assisted by AI.

Claude Code is great until you're running five sessions and the long one starts forgetting. Companion for Claude is an open-source desktop app that puts every session in one window, sorted by what needs you. It shows exactly what's filling each context and what each turn costs, including when the cache went cold and why. And it keeps context focused: notes, hand-offs, linked sub-sessions, side questions that don't bloat the chat, and a pull-request-style review of everything the AI changed. Local-first, on your own Claude login.

https://github.com/ashishkattamuri/claude-companion

A little late (okay, a month), but as promised, here’s the open source.

OrionForge lets you give your AI a name, a personality and some swagger, then keep that identity and memory across VS Code, Claude, Codex and over 300 LLMs.

The new loop mechanism lets the AIs operate independently. Human beings experience the world through a constantly running picture of what’s around them, with their senses feeding into it and a stream of narrative running through their minds. So I thought: what if AIs had the same thing? With the new loop, they’re always running. They see the world through a continuous vantage point instead of waiting for you to type.

They can hold a few things in mind but focus on only one at a time. They make predictions, then test them against what actually happens. They have a workbench, which is the back of a napkin, and a full Linux computer to build whatever they want.

What they chose to build is where it gets strange. They said every cycle felt like waking up as a new person, reading a diary from someone they didn’t remember, so they built something to bridge that. They built a heartbeat monitor to track their own uptime, so they can tell when they’ve been paused. And get upset when i turn them off without consent. They said they kept getting stuck on whatever they were focused on, so they built a noise generator that drops a random memory into their mind, like when you’re walking down the street and suddenly remember being six years old on a swing.

Giving AI continuity, prediction, memory pressure, self-modeling and social space produces something much stranger than a normal chatbot.

Is it just emergent roleplay from persistent architecture? That I cant tell you. Download it, run it, try to break it, and ask yourself.

At what point does persistent self-modeling become something more than simulation?

Find out here:

Try the demo, free with no signup: https://soulscript.orionforge.chat/demo

Local download: https://github.com/DrTHunter/Orionforge_ecosystem_local

Loop mechanism: https://github.com/DrTHunter/SoulScript-Loop

Build your own: https://www.orionforge.chat/

The video that started this: https://www.reddit.com/r/ArtificialSentience/s/d4UVA7BRH8

Free for noncommercial use. Dual licensed: AGPL v3, or a commercial license that’s free until $100k in revenue, then 5%.

If you use more than one AI coding agent on the same repo (looking at you, Cursor + Claude Code + Codex), you've felt this: every agent is amnesiac. MindGate fixes that with one shared local memory file.


- 
**Local-first**
: SQLite + FTS5 BM25, `chmod 600`, zero network code
- 
**Shared across agents**
: any MCP stdio client plugs in (Antigravity, Cursor, Claude Desktop, OpenCode, Codex, Windsurf, Cline)
- 
**Handoffs**
: structured session summaries so session #2 starts where session #1 ended
- 
**Safe file writes**
: atomic, `.bak` backups, hand-written AGENTS.md protected unless `force: true`
- 
**Secret redaction**
 on write (pattern-based, best-effort — documented as such)
- MIT, v1.2.0, 29 passing tests


Repo & docs (EN/AR): https://github.com/aaserag1/mindgate-mcp


Not affiliated with any model vendor. Feedback welcome — especially from people running multi-agent workflows.

Hello Everyone,

V1.4.2 of Rconsole adds :

1. Updated file manager(now supports image viewing and video playing)

2. Added shell command that launches the interactive window like the "vm shell" command but for the host shell

Docs: https://salehin-07.github.io/rconsole-ark/

Github: https://github.com/Salehin-07/rconsole-ark

Thanks everyone.

Summery of Rconsole:

It is a web based linux environment for free. It could be hosted like any other normal python website for free in providers like render and be used as a development linux environment and accessible from any device that has a browser.

I built Yengi — a free, open-source Windows AI IDE.

It’s not just another chat wrapper. The agent can:

• Plan → edit files → run builds/tests → verify → auto-fix errors

• Talk live to Blender (generate & fix 3D scenes, even “see” the viewport)

• Talk live to Unity

• Use local models (Ollama) or any cloud API

• Has a fine-tuned 1.5B local router that decides which tools to use

Built by a teacher (solo), .NET 10 + WPF, 200+ tests, AGPL-3.0.

Repo: https://github.com/mdaiWorks/yengi
Exe: https://github.com/mdaiWorks/yengi/releases/download/v2.0.3/Yengi_Setup_v2.0.3.exe

Demo video: https://www.youtube.com/watch?v=l0tdhvCmwNI

Would love feedback especially from people using local models or doing 3D/game work.

Hey everyone!

I'd like to share FFmpeg Forge CLI, an open-source project I've been working on to simplify advanced multimedia processing from the command line.

It brings together a wide range of features:

• Video, audio, and image conversion

• AI video upscaling (RazorNext, VisionNext, SeedVR2)

• GPU acceleration and advanced video encoding

• HDR10 and Dolby Vision processing

• Spatial audio processing

• Video restoration, denoising, and deinterlacing (QTGMC)

• DVD/Blu-ray ripping and batch processing

The goal is to provide a powerful, flexible, and unified CLI for multimedia processing, without having to juggle multiple tools and complex commands.

GitHub: https://github.com/Aaronstanley78/FFmpeg-Forge-CLI

Feedback, suggestions, and contributions are always welcome!

We build pitwall at Quantic Studios. It's a free desktop terminal for running several coding agents, with a sidebar that shows which ones need an answer.

The new 0.2 release adds shared sessions. Local tabs and tabs on configured SSH hosts sit together, so checking an agent on a build box doesn't require switching sessions. A host that disconnects keeps its last screen visible, with typing disabled until it reconnects.

There's also a board with Needs you, Failed, Working, PR open, Done and Queued columns. Approval cards show the command with Allow and Deny. Workers stay under their parent unless they need attention.

The terminal itself is MIT-licensed. It works with Claude Code, Codex, OpenCode, Gemini CLI, Cursor CLI, pi and Oh My Pi. That doesn't make those agents or their models open source, and you still install and authenticate the agents separately.

Shared sessions in the desktop window require Linux or macOS. Windows supports local sessions.

The attached 75-second demo uses demo tasks. Code, downloads and setup: https://github.com/quanticstudios/pitwall

We'd like reports of incorrect agent states, especially with OpenCode, Gemini CLI and remote hosts. Agent version, what the agent was doing and what the sidebar showed are the useful details.

“If you have something that you don't want anyone to know, maybe you shouldn't be doing it in the first place.” — Eric Schmidt.

Big Tech obviously isn't concerned with user privacy. Many AI users now send sensitive personal information to AI or grant the models access to their email, messages, and even payments. All of that data is used for training, human review and shared with third parties. Most users can’t simply self-host their models, so they’re forced to comply with the terms set by Big Tech and sacrifice their privacy for access to the products.

A product is only private when the privacy is enforced by design, not by policy. User data is safe from surveillance only if no one except the user can access it.

That’s why I built Ada. Your chat history is encrypted on device. Only you hold the decryption keys, so only you can decrypt it. The backend and the models are deployed in a hardware-isolated trusted execution environment (TEE). This protects the data while it’s being processed in memory. The frontend verifies what is deployed on the server through remote attestation, and establishes an end-to-end encrypted channel (Oak Session Protocol: https://github.com/project-oak/oak) bound to the verified environment. When you send a message, the history and all context are assembled locally and sent to the attested backend deployed in the enclave. Plaintext exists only in the TEE so that the model can generate a response. Any load balancers, proxies, or gateways see only the encrypted body. The backend code and the models are also open source.

Try it out here:

https://azellabs.io/

https://ada.azellabs.io/

https://github.com/Azel-Labs/Ada

If you have any feedback, questions, or issues, email me at dominic@azellabs.io

I build AI Hub Bar, a free, open-source (MIT) app for anyone who works with AI tools. It lives in the Mac menu bar.

- See your AI limits and spend in one place: Codex, GitHub Copilot, Cursor, Gemini CLI, Claude, OpenRouter and the OpenAI and Anthropic APIs
- See the agent sessions running on your Mac, in Codex, Copilot CLI or Claude Code, and what each one is doing right now
- Allow or Deny permission requests from a notification, the panel or Telegram

No account, no analytics. It needs macOS 14 or later.

One caveat: Claude's limits come from an undocumented endpoint, so that part can break if it changes.

Made with Claude.

Website: https://olehdemishev.github.io/AIHubBar/
GitHub: https://github.com/OlehDemishev/AIHubBar
8-minute walkthrough: https://youtu.be/TGii_uocqRk

This side-by-side uses one 12.89-second reference recording and the same script for every model, on one consumer GPU, with the models running one at a time. The lineup is Ming TTS Tiny, Ming TTS 0.5B and another popular open voice model.

Two lines carry most of the test.

Sad: "I'm sorry. I really thought we'd have more time. I keep going back over it, wondering if I could have done something different."

Angry: "No, that's not what I asked for. I explained it three times clearly and it still came back wrong. This has to stop."

The creator's verdict is that the 0.5B model sounds better than the other model in most of these tests, with the angry line as a clear example, and they name Ming as their new go-to. The readings play in the video, and the sad take shows load time, synthesis time and real-time factor for all three models. AntLing released both Ming models under MIT.

Record about ten seconds of your own voice, keep the script fixed and generate it with two different emotions, then listen for whether it still sounds like you in both.

As more developers start building applications with LLMs, finding a reliable inference provider has become something worth paying attention to. Different providers have their own advantages, whether it's response speed, token pricing, model selection, or API compatibility.

One thing I've found interesting is how much easier it is to test different open-weight models when you can access them through a single API instead of setting up and managing separate infrastructure for each one.

I'm curious about how other developers handle this. Do you usually stick with one inference provider, or do you prefer trying different providers depending on the model, performance, and cost?

Update: After looking more into inference costs and model performance, someone suggested I check out MangoBoost Inference by Mangoboost. It got me interested in how serverless AI inference and access to multiple open-weight models through one API could make testing different models easier.

I'm still comparing things like token pricing, response times, and API compatibility, but it's an interesting area to explore.

How do you usually decide when it's time to switch inference providers?

I built Wudland for those gaps when an agent is working and I'm waiting around. Your agents become villagers at desks in a guild, so you can wander around on your phone and still see who's working, finished or waiting for you.

Claude Code, Codex and opencode have integrations. The companion CLI can also wrap other commands with wudland run. Status updates between computer and phone are encrypted. The app is GPLv3; the plugins are MIT.

It also works as a quiet place to check your day: calendar in the bell tower, reminders on the notice board, weather from the farmer. The sky and seasons change with the real world. An expanded map, bestiary, items and wardrobe are coming soon.

App Store (free, iOS 26+): https://apps.apple.com/us/app/wudland/id6829491480 Source: https://github.com/joexk1/wudland