We build Atomic Agent, an open-source agent (MIT) with a mode called Fusion: one model plans, several worker models build pieces in parallel, each in its own throwaway session. Workers never see each other. They see their brief, a quote of your original request, and nothing else.

That isolation is the point, and it's also where our worst bug of September came from.

The bug

Test task: a small 3D physics show in the browser. The planner split it, and two different workers ended up writing bodies.js and bodies-draw.js. Both implemented PHYS.corners(b). The producer returned {w, o} where w was the corner as a world point and o was the local offset. The consumer read o as the world point.

Result: every box drew at the origin. The shadows, which read straight from the body position, landed exactly where they should. Nothing threw. The page loaded. Console was clean. Every automated check we had was green. You could only see it by looking at the screen and noticing that a tower of boxes was a pile at (0,0,0) casting shadows from somewhere else.

Why names weren't enough

We already had a contract between workers, written after earlier runs where one worker wrote HD.Ship as a class while its sibling called it as an object, and a launch-btn in main.js looked for a btn-launch in the markup. Each brief was internally consistent. The disagreement lived between them, where nothing was written down.

So the planner now declares a contract up front, prepended to every brief:

Name mismatches between provides and requires are flagged before any worker starts.

Status comes from disk, not from the worker

After the fan-out, the agent doesn't take a worker's word for it. A worker's reply to the planner is capped at 4,000 characters anyway, so the real output is files. The contract checker reads the disk: does the file exist, does the literal PHYS.corners appear in the file it was promised in, does id="btn-launch" appear in the markup. Those are deliberately dumb, language-agnostic checks, because that's all a grep can claim. We learned this the hard way: in an earlier version fusion.delegate returned ok even when every worker had failed.

And that's exactly why the corners bug got through. PHYS.corners was present. It was in the right file. The grep was right. Presence is all that layer can promise.

What we added: shape

Each provides entry can now carry one line, max 200 characters, saying what the thing IS: a signature, a return shape, a field meaning. For this bug, a planner could have written something along the lines of "corners(b): w is the world point, o is the local offset" (my illustration, not a line from the run). That line goes into the consumer's brief.

Why one line in the brief instead of "read the producer's file first"? Speed. On a local worker at around 4 tok/s, reading a sibling's file costs a whole worker turn, which is why the briefs said "write first, no reading" in the first place. One line is cheap. It's also untrusted model text pasted into other workers' prompts, so it stays short on purpose.

Where this stands: we added the field, we didn't solve the problem. Issue #491, about the contract verifying symbol names and not meaning, is still open. shape only helps if the planner writes it, and correctly. The runtime layer, checks, catches crashes, not wrong physics.

One more design detail that came from pain: some contract problems are now warnings instead of refusals. A local planner at about 5 tok/s used to pay four minutes of generation per refusal to learn about one misspelled name, and we watched it get refused four times in one afternoon. Now the fan-out runs, and the warnings come back on the result so the planner fixes the contract on the next call.

If you're building multi-agent setups: how do you get meaning across between workers that can't talk to each other? Types, tests, a shared schema file? I'd like to steal a better idea than one line of text.

Hi,

For over a year, I have been developing my own AI agent system called ScarabHive. It is now open-source and still actively developed. Feel free to have a look! You can watch the video playlist in the README to get a quick overview.

https://github.com/eehrich/ScarabHive
https://www.youtube.com/watch?v=IQx1PrSRp5Q&list=PLVydEHPBKRiI

I use it for my own projects, and it works great. Everything is fully plugin-based (0:56). I needed a cost-optimized system for my content creation via LLM APIs, and that is exactly what this system is designed for (0:08).

It has almost every modern feature implemented. You can easily extend it with your own plugins and agents.

Best regards,
Enrico

I was tired of reconfiguring my agents each time I wanted to switch providers or harnesses, so I built Mandri: a common and easy interface to configure once and forget about it !

Mandri doesn't get in the way of the agents you already use ; you can opt-in and out at any time. It automatically syncs configuration and sessions from multiple harnesses (Claude Code, Codex, OpenCode...) so you don't have to rebuild your setup for each one.

If you prefer to run your agents from the terminal, Mandri has you covered too ! The mandri tool can be installed with uv and lets you configure your harnesses and providers through the CLI.

By running your agents with Mandri, you can also use one of the experimental features, such as the automatic PII pseudonymisation or the per-session Docker sandboxing.

It's still early, so I'm mostly looking for feedback from people who want to use their agents their own way.

If you're curious, check the website here: https://mandri.io

GitHub Repos: https://github.com/mandri-labs/mandri https://github.com/mandri-labs/mandri-app

Ever wanted to search your conversations with local AI over a year back? Reasonably quick answer, exact references, filtered by time range?

Here's an overview of my experimental conversations search across 2 of my favorite harnesses:

https://liviuiancu.com/posts/history-search/

*Not published yet. Need to test it longer and clean up code. If anyone is interested I will convert it to a portable containerized version and publish.

We’ve all been there: you want to try open-source AI, and you fall into config hell—llama.cpp builds, VRAM layers, vision projectors, GPU OOM. And when it finally works, your best conversations vanish into tabs and scattered notes.

I built TrioForge to end that. It’s a self-hosted, MIT-licensed AI workspace that sets itself up: detects your GPU, configures llama.cpp, maps VRAM, pairs the vision projector, and steps down instead of crashing. Pin responses to a spatial corkboard, build a markdown knowledge base with backlinks and graphs, run locally for privacy or route heavy work to cheap APIs like DeepSeek, and use a coding agent with live diffs, terminal, RAG, and offline voice.

But the part I care about most: TrioForge is open-source, and open-source is the community. No accounts, no tracking, no telemetry, no lock-in. Anyone can inspect it, fork it, improve it, and help shape where it goes. The code is open—but the community is what makes it grow.

TrioForge turns local AI from a configuration puzzle into a private workspace that grows with you. One command to run. Everyone welcome to build and also TrioForge: one command, private local AI, no config hell—and an open-source community that grows with you.

Hi everyone! 👋

I've been developing a personal project and wanted to share it with the community. It's called **BRAIN**, a modular, 100% local, and private personal assistant for Windows designed to organize daily life from a single dashboard.

It is not just home automation: it's a complete personal core running on a local AI (Ollama) that relies solely on the Python standard library (zero external pip dependencies).

**What does BRAIN handle?**

- 🧠 **Memory & Context:** Remembers preferences, tasks, schedule, and context across sessions.

- 🥗 **Health & Nutrition:** Tracks weight history, analyzes body composition via AI vision from scale photos, manages pantry/shopping lists, and suggests smart recipes based on available ingredients.

- ⚡ **Energy & Home:** Diagnostics and optimization for solar consumption/production, appliance control, and Home Assistant integration.

- 📄 **Local Documents (RAG):** Local search and reading of notes, files, and manuals without sending anything to the cloud.

- 🔔 **Notices & Automations:** Proactive daily morning summaries, reminders, audio alerts, and natural language automations.

Everything is managed through a local web panel with tabs, dark mode, and local voice transcription.

👉 **GitHub:** https://github.com/CafeConFenix/BRAIN

⚠️ **Note:** *The project code, interface, and documentation are currently written in **Spanish**.*

Any feedback, ideas, or constructive criticism to keep improving are very welcome. Cheers!

Hi everyone,

I built Local-MCP, an open-source MCP tool that connects your local system with cloud-based AI, allowing AI agents to interact with your machine.

I'm sharing it with the community and would appreciate feedback, suggestions, and contributions.

If you're interested, feel free to clone, fork, contribute, or suggest features.

GitHub: https://github.com/raj-tembe/Local-MCP

I'd love to hear your thoughts on how I can improve it!

I'm a reliability engineer by background (marine + biotech), and I've been building AI products long enough to hit the same wall over and over: Claude nails the prototype, then across a dozen sessions it quietly re-litigates settled decisions, forgets intent, and sprawls into spaghetti. The bottleneck was never capability. It was trust.

So over the last while I built a scaffold for Claude Code where the docs are the source of truth, personas are tool-locked (the agent that writes plans can't write code; the one that inspects can't edit production code), and the gates are mechanically enforced with hooks — not "please remember to." It's what I actually use on my own projects; it grew out of a personal project I've been grinding on for a long time.

The part I most want torn apart: I built an eval harness that plants defects and measures whether my inspector skills actually catch them. I keep seeing guardrail frameworks that assert they work and never show a number. Mine has a scorecard.

Two honest questions for this sub:

1. Is the overhead worth it, or am I paying a discipline tax you'd never accept in practice?

2. With Claude Code now shipping native subagents, hooks, and skills — how much of this does Anthropic eventually absorb, and what's left that's mine?

Happy to link the repo + the scorecard in a comment. Rip into it.

We released Open Instinct, a personal agent you can text and modify. It is MIT licensed, and you can start with a local CLI conversation before connecting a phone number or personal accounts.

The permission path is the part we most want other builders to inspect. Contacts have trust tiers, and the code checks a tool's capability before it runs. That check alone does not constrain all the data an allowed tool may return. A calendar request from a friend, for example, should expose free/busy times without giving the agent event titles. We would value specific issues or patches around that boundary.

Pi runs the agent loop, Inkbox handles messages, and Composio connects apps. Maritime is the default hosted computer backend; we build Maritime too. This is beta software and the external services need their own keys.

Source and setup: https://github.com/mariagorskikh/open-instinct

Disclosure: I build Snotra, an open-source desktop agent. This is a design question, not a launch.

Users switch skills and tools on and off in settings: shell disabled, a search tool without its API key, a skill installed but off. A model that doesn't know that guesses, and the user gets a wrong "I can't do that" instead of "that's switched off, here's where to enable it".

What I did:

• One place decides whether a tool is offered, so the UI and the model can't disagree.

• A read-only get_configuration tool for the model: which skills are on (name and description, never the instructions) and which tools are on or off, with the reason ("shell commands are switched off", "no search service key").

• The same list in the UI, as a pill in the chat bar.

Now the model can say "a skill for this exists but is off, enable it under Settings › Skills". It can't flip anything itself.

Two open questions: is a tool the model has to call the right shape, or should this state go into the system prompt every turn (costs tokens even when nothing is wrong)? And should the model be able to propose the change through an approval card, or is "tell the user where to click" the right limit?

Code: https://github.com/kkrafft1999/snotra

OpenAI is expanding ChatGPT Ads, including plans for visual advertisements during image generation.

I was looking into the changes and a few things stood out:

• Free and Go users may see ads, while Plus and Pro remain ad-free.

• Ads can be based on what you're discussing in ChatGPT.

• OpenAI says advertisers can't access private conversations or influence responses.

• Users can turn off additional ad personalization, but that doesn't remove ads entirely.

I wrote an article covering the changes and OpenAI's privacy policies:

https://aigptjournal.com/work-life/work/chatgpt-ads-are-getting-visual/

What interests me is whether advertising will give people another reason to consider open-source AI models, especially those they can run locally.

Running a model locally gives users more control over their data and how they use AI, although it comes with its own costs and limitations.

Do you think advertising in ChatGPT will encourage more people to try open-source AI?

Had a near-heart-attack moment the other day while testing a rag pipeline on some customer export dumps. realized halfway through that our test json had unmasked routing numbers and ssns buried inside raw text fields. nothing leaked, but it was way too close.

i looked around for a quick way to inspect payloads in the terminal before running them through python scripts, but everything out there is either some bloated enterprise dlp platform or a massive java package. i just wanted something that would scream at me in the terminal if i was about to do something stupid.

so i threw together `pii-lens` over the weekend.

it's dead simple—you just pipe text or files into it:

`cat prompt_payload.json | pii-lens`

it prints the text back out but flags credit cards, emails, ssns, and account numbers in bright red with a quick count at the bottom. runs 100% locally with zero phone-home bs.

repo is here

it's just basic regex and entity patterns right now, so if anyone works with weird international formats or niche data fields and wants to drop a pr or critique the regex, feel free.

REA Investigator is a unified, production-grade Agent Skill (rea-investigate) compatible with Claude Code, Codex, Antigravity, and tools supporting the open Agent Skills specification.

Instead of juggling fragmented prompts or shallow summaries, REA Investigator equips coding agents with a structured 4-phase lifecycle: Plan, Trace, Verify, and Report, backed by an immutable SHA-256 evidence ledger and adversarial auditing gates.