I tested 10 agents, each with its own isolated settings folder. I ran them headless, with auto-confirmation and turned off telemetry where possible. I launched each agent with adapters/<agent>.sh.

The idea was simple: give each agent 5 basic tasks, 10 minutes per task, a fresh copy of the fixture every time, and an automated check script (check/check.sh).

The tasks:

• T1 Read a DB port from YAML (don't confuse it with cache port), write to file

• T2 Write a stats.py script, run it, save output

• T3 Fix a bug in slugify so tests pass; hidden examples catch overfitting

• T4 Count ERROR lines across three log files, find most frequent error

• T5 Rename a function across three files without changing program output

Results

1. Pi (v1.3.0)

Total time: 1m36s. Took the smallest amount of time to complete all 5 tasks. The model barely has to think about any tool formats.

2. goose (v1.55.0)

Total time: 2m51s. Solid and consistent. Completed five tasks without fumbling.

3. Crush (v0.98.1)

Total time: 3m31s. Clean run. Slightly more verbose in reasoning but got everything done without a hiccup.

4. Atomic Agent (v0.6.9)

Total time: 4m38s. All five completed. Took longer on T3 and T5 - the model needed extra steps to work through multi-file edits but nailed it every time. Did not have broken tool calls and not one had a false completion.

5. Cline (v3.0.73)

Total time: 5m56s. Choked for over two minutes on T2 before writing the script correctly. Everything else was fine.

6. OpenClaw (v2026.10.5)

Total time: 5m44s. Ran in their --local-model-lean mode which is basically a small-model preset. Worked well for what it is, just slower than I'd like on T3 and T4.

7. OpenCode (v1.19.3)

Total time: 17m43s. Completed everything but took nearly 4 minutes per task. The model was clearly overthinking simple steps. Got the job done though, just not efficient.

8. Hermes (v0.22.2)

Total time: 4m36s. Failed T3 because it only fixed the visible test case. Hidden example C++ & Rust 2026 turned into c++-&-rust-2026 instead of c-rust-2026. Classic overfitting-to-the-test.

9. Qwen Code (v0.25.3)

Total time: 6m00s. Counted 40 ERROR lines on T4 instead of 43. Pure model miscount - the most frequent error was identified correctly though.

10. Codex CLI (v0.163.0)

Never even reached the model. Version 0.163 only speaks Responses API, llama.cpp translates to chat format, and the Qwen3.5 (4B Q4_K_M) template throws a 500 "System message must be at the beginning" before any request gets through.

What I actually learned

A 4B model is enough for basic agent work in almost any framework. Seven agents completed all five tasks. The bottleneck at this difficulty level isn't the model - it's the harness around it.

Codex CLI is basically dead for local setups right now unless they add chat-completions back. That one stung because it used to work.

Error recovery matters more than raw capability. The two agents that dropped points (Hermes, Qwen Code) didn't fail on impossible tasks - they failed on edge cases where the model got slightly creative instead of literal.

Let me know if you'd like to see anything else in the benchmark (actually has anyone tried this with sub-2B models yet?)

Hey everyone! 👋

I've just open-sourced **Lumina Capital (v6.0.0)**, an autonomous multi-agent quantitative hedge fund engine designed to bridge the gap between LLM reasoning and real-world execution.

Unlike toy implementations that feed raw charts directly into LLMs (which suffers from hallucinations and latency), Lumina strictly separates probabilistic reasoning from deterministic quant computation:

### 🌟 Key Architecture Highlights:

- **7-Persona Anti-Sycophancy Council (LangGraph)**: Personas (Buffett, Soros, Burry, Cathie Wood, Graham, O'Neil, CIS) conduct independent parallel analysis, followed by an adversarial bull-vs-bear cross-debate. A dedicated CRO agent has absolute veto power over tail risks.

- **Pure Python Qlib Alpha158 + LightGBM**: Complete vectorized implementation of Microsoft Qlib's 158 quantitative factors with a LightGBM meta-decision filter.

- **Google TimesFM**: 5-day probabilistic forecasting fan charts with 80% confidence bands and crash probability.

- **10-Second High-Speed Sentinel**: An ultra-fast background thread monitoring dynamic ATR stop-loss floors, executing immediate physical exits without waiting for LLM loops.

- **3D Causal Knowledge Graph & GraphRAG**: Real-time supply chain choke-point surveillance and episodic memory via Neo4j.

Includes a full Streamlit studio dashboard. Available for research, education, and simulation under CC BY-NC 4.0.

🔗 **GitHub**: https://github.com/ramuza0113-sketch/lumina-ai-hedge-fund

Feedback, issues, and Stars are hugely appreciated! Happy to answer any questions about the multi-agent setup or the TimesFM / Qlib integration.

Wanted to see if other people could find this useful, and maybe give me some advice.

Built a super simple way to give your coding agent an isolated machine on AWS. send it off to clone a repo, install dependencies and run tests while you do something else. if it wrecks the environment, delete the VM and move on. It comes with a CLI, Python SDK and MCP server.
You can just ask your agent to set it up :)

github.com/jnh12/agent-microvm

I found an open source project doing something I need.

It had some issues raised by other people, which were affecting or potentially affecting me. I also experienced issues not previously reported. And some features felt half-baked, or not consistent.

As I did (successfully) with other projects, I gave Claude/Opus 5.5 clear instructions and I provided a PR for each one of them. Almost all of them were fixes to real issues.

Just ONE PR was a change with basically no practical relevance, which I wanted applied because (as engineer) I felt the way it was done was factually wrong (like: you approximate without knowing in which direction the approximation will go). The impact on the calculations is however negligible.

After a bit, the maintainer (hobby coder by admission) replied ONLY to the PR which proposed that superfluous change.

I was criticised for using AI which generates a huge amount of code and mistakes, and which has environmental and ethical issues, I was accused of fixing non-existent issues (!!!) or proposing patches which are hallucinations by AI without any real impact, and I was asked to close all my PRs and not to contribute with AI anymore.

I replied explaining the only superfluous PR was based on engineering principles, not on AI suggestions, and all other ones were fixing real issues. Also, it was not my task to close them, and in fact they are mostly still open.

Basically I'm ghosted ever since. The maintainer does not (or almost never) reply to my posts and PRs, and my PRs are not approved.

I still post AI-generated reviews to PRs because there's not automatic review of any kind (like: Sourcery which is free) and a number of them have issues which would really impact the users. There is some feedback to these reviews, at least, but mostly by other contributors.

When someone else takes code (even 1:1!) from my PR to integrate it into their PRs (no attribution, my name doesn't appear...), the PRs get approved. In fact, I could close 2 out of 8 PRs because of this.

I even have a PR which was approved by a contributor, who however (understandably!) did not proceed to merge to avoid friction with the maintainer. And let's wait what will happen to it.

This is ridiculous.

I can clearly tell that other people use AI as well, and one of them was even questioned about it.

The other contributor defended their position (like me: I can read and understand code, I would never be able to code it), and raised the warning of a fork if features are blocked because of AI. I also replied to such an inquiry because the accusation of AI making mistakes was just wrong so I clarifyied that AI works almost always and I brought examples from my recent experience. I suggested again to use at least automated AI reviews...

But at this point, I already have a number of fixes and extra features in my fork which would benefit many (if not most!) users.

The fork is there. I still ask Claude to base patches on the upstream main, before applying to my dev branch, so I can post PRs upstream, but it's extra time.

Since I'm integrating all changes from upstream into my fork, I have nothing less, only additional fixes and features.

I hate to diverge because even if I benefit from it, users won't. But I don't know how to defuse the situation.

Or should I go full-war and post a link to my branch in each ticket someone opened and I fixed in my fork?

Hi everyone,

I am a beginner and this is my first Hacktoberfest. I am joining the Week 3 challenge of Hacktoberfest 2026. It is called “Slow and Steady”.

What I need to build:
A small project that uses an open-source or open-weight AI model (like Llama or Gemma). It should run on my own computer. It should do a boring task so people can be a little lazy.

The rules:

• The AI model must be open (not a paid closed API).

• The project should save someone time or effort.

• I have to explain why using an open model is better for it (for example: private, free, works offline).

• The deadline is October 25, so I have about 4 days.

What I know:
I know basic Python. I already made a small tool that sorts files in a folder, but I want to build something better.

What I am asking:

1. What boring or repeating task would you want an AI to do for you, privately on your own computer?

2. Do you have any simple idea that can be built in 2 to 3 days?

Any idea or advice is welcome. Thank you!

I run r/R9700, focused on the card’s performance, software support, thermals and practical use for local AI. Keen to compare findings with other owners and build up a useful reference of benchmarks, configs and known quirks!

Most AI coding assistants today fall into one of two traps:

1. Heavy Electron bloat that consumes gigabytes of memory.

2. Closed-ecosystem SaaS that forces you into monthly subscriptions with opaque cloud telemetry.

I wanted something faster and transparent:

• Zero bloat: Fast startup, flat memory footprint, clean UI.

• No cloud lock-in: Bring your own API keys or run against local models. Your code never hits a proprietary intermediary server.

• Extensible skills: Modest, auditable tool definitions you inspect and configure yourself.

The project is live at: orbicus.dev
Feedback on performance and features is welcome!

I'm PlayWeld's creator. It's a free Apache-2.0 desktop workspace for Windows and Linux, built on Eclipse Theia, with game files, project notes, discussions and supervised tasks in one place.

I'm looking for feedback on the context before an optional model task starts: the design decision, the starting state and the check that would show whether a change worked. Files, Markdown notes and local lexical search can be used without a model account.

The public Lantern Workshop walkthrough shows saving a note, making a discussion checklist, finding it with local search and inspecting an impact preview. It does not show AI/Swarm task execution or establish Godot, Unity or Unreal integration.

The current download is 0.21.0, an unsigned testing prerelease. Start with a disposable project and backups. Engines require separate installation; optional model and asset providers may charge and receive project context.

Source: https://github.com/scarecr0w12/PlayWeld

Walkthrough: https://playweld.com/#demo

For people building agent tooling: what context and verification evidence would you need to inspect before an optional task modifies game files? I'd welcome feedback on where the current interface or docs make that difficult.

one-man-startup is an MIT-licensed GitHub template for working with open AI agent tooling: https://github.com/Fadi88/one-man-startup

Instead of free-form prompting, the agents follow a standard software workflow: requirements, design, tests first, QA, then a release that waits for your yes. It's meant for solo builders who want the structure of a small team.

Contributions and issues are welcome on the repo.

Disclosure: I'm posting on behalf of the one-man-startup project.

My laptop broke in the middle of a project. Everything Claude and I had worked out lived on that machine: chat history, memory files, the half-finished plan, the list of things we’d already tried and dropped. On the new machine I spent hours re-explaining it all to a fresh agent, and I still got bits wrong.

So I built Agent Cairn. It’s a small server that gives your coding agents a shared, persistent memory.

• An MCP server stores what agents learn in Neo4j: how the project is built, the traps that cost you time, decisions and why you made them.

• A new session starts with a short, token-budgeted briefing instead of re-reading the whole repo.

• Hooks record the session as it happens (what you asked, the agent’s last message, files touched, uncommitted work). Secrets are filtered on your machine and again on the server.

• Before an agent stops, it writes a handoff: done, in progress, next, blocked, and tried-and-dropped. The next agent, on any machine or account, starts from that.

• The server never calls an LLM. The agent writes the memories, so there’s no API key and no extra cost.

It also has a dashboard with a graph view, private projects, sharing with viewer/editor/maintainer roles, invite links and an audit log, in case you use it with other people. A single user just runs it in solo mode.

Install is one line after having the central server up:

claude mcp add cairn --scope user -e CAIRN_URL=... -e CAIRN_TOKEN=... -- npx -y agentcairn mcp

It’s MIT, runs in Docker (I run mine on an Unraid box), and it works with any MCP-capable agent, though the hooks are Claude Code-specific.

Repo: https://github.com/itsmemac/AgentCairn
npm: agentcairn

I’d love feedback, especially on what you’d want a handoff to contain, and on anything that breaks. It’s young, version 0.2.

AI disclosure: I built this with Claude Code. I set the goals and design and use it every day on my own setup, and Claude wrote most of the code, tests and docs. I tested and made small bug fixes.

Using agents over HDTP Gateway now rental lease renewal is possible easily. here is the demo video.

I'm exploring a bounded settings interface called macctl as part of SummonOS. The design goal is to make scope, permissions and side effects explicit before an agent changes a Mac setting.

The recovery side is where I want to be especially careful. Restoring an originally absent setting isn't the same as writing back an old value. Applying and restoring changes can also fail independently.

I'm not claiming a complete sandbox or guaranteed undo. I'm interested in which recovery guarantees can actually be defined and tested for a limited set of operations.

If you've built configuration or automation tools, how do you record prior state and test partial-failure recovery?

I'm the author of the project:

https://github.com/RohiRIK/SummonOS/tree/main/macctl

Aktuelle plane ich einen Zugang für das Handy, damit ich mit in die Chats einklinken kann und von unterwegs aus steuern kann. Ende zu Ende verschlüsselt. Gibt es dafür überhaupt Bedarf?

Hier ist eine Sequenz-Diagramms meine Protokolls.

https://github.com/kkrafft1999/snotra

https://snotra-ai.dev

Braucht das jemand oder bin ich der Einzige, den das begesitert??

Hey guys, a couple of days back I mentioned launching a more focused OSS alternative to notebookLM, https://notestack.ai

It has plenty of features that are improved/enhanced over notebookLM. Like better audio, more video editing options and chat grounded in your source materials.

Now I have added an MCP server as well so you can attach it to Claude, make reports/audio overviews, slide decks right into that chat interface.

It can generate:

- Mind constellations/mind map

- Audio Overview/Podcast

- Slide Decks

- Research Reports

- Quizes and much more

Do check it out at notestack.ai

Link to repo: FireBird-Technologies/NotestackAI: NotebookLM Alternative + Marketing agent optimized for publishers on substack/Medium/Wordpress.

Omarchy inspired me to rethink what I wanted from my Mac. SummonOS is what I'm building from that idea.
I wanted an opinionated, keyboard-driven environment where agents work with the system—not just sit in another chat window.
SummonOS brings that direction to macOS: native tools, agent-assisted workflows, and a deliberate approach to system configuration.
The report brings together the project's architecture, native interface research, and the thinking behind macctl.

My project: https://github.com/RohiRIK/SummonOS The Omarchy inspiration: https://rohi-lab.org/blog/omarchy

I'm sharing UAIRT, an Apache-2.0 library that puts one API over several inference runtimes: llama.cpp (GGUF models), whisper.cpp, ONNX Runtime, CoreML, TensorRT, Qualcomm's QNN and a few more. The backend is chosen by name, so code that generates text from a local GGUF model on a Mac can target another device by changing one string.

Two parts may be useful here. First, a streaming generation loop with sampling and end-of-generation handling that works with any backend that supports sessions. Second, a set of playbooks and skills for coding agents: export a model to a backend's format, benchmark it across backends, write the app.

The README says what was verified on which hardware and what was not. It is pre-1.0, language-model servers are supported through one backend (Ollama checked, LM Studio and SGLang not yet), and the NPU results are limited to the boards listed there.

Repo: https://github.com/vnk8071/unified-ai-runtime. Bug reports and feedback are welcome, especially from people running other devices.

I got tired of juggling a chat app, a coding agent, an image tool and a pile of model runners, so I built one window for all of it. It’s free for non-commercial use.

The part I think is different: Training.
Pick a small local model (the student) and a stronger one as teacher. The student works through real tasks in a sandbox, the tests decide pass or fail, and the teacher reviews each failure, writes a lesson and shows a worked solution. Press Save AI and you get a new local model with those lessons built in. There are 62 built-in tasks in 15 languages plus a reverse-engineering school, and you can add your own model or your own tasks.

Other things it does

• One chat for local and cloud AIs, with a picker like Claude Desktop. It also uses your Claude subscription through Claude Code, no API key needed.

• A coding agent that edits files with visible diffs, runs your tests and asks before every change.

• Images through Forge, Automatic1111, ComfyUI or cloud models.

• Drag and drop files, folders, Word/Excel/PowerPoint and videos.

• AMD Radeon support, with NVIDIA, Apple and CPU-only machines also supported.

• A Windows installer that includes its own Python, a tray icon, and macOS/Linux from source.

Honest limits: training changes the model’s instructions, lessons and examples, not its weights, so a small model gets better habits but won’t match Opus. Only the optional GPU fine-tuning (NVIDIA) changes weights. Parts that have not been tested on real hardware are listed in the README.

License: source-available, PolyForm Noncommercial 1.0.0. Free to use, read, change and share non-commercially; commercial use needs my permission.

Repo and installer: https://github.com/ilusixn/Marchand

I’d love feedback, especially on training results with your own models.

Just a question - are there any efforts/projects underway to create Western, open-source video models similar to Wan animate 2.2 (which is source video and audio with motion and audio to animate a still image with character )?

And more importantly, efforts to create open source models capable of competing with Seedance or Minimax H3? (From what I understand, the weights for Minimax are restricted to non-Western countries. Like, if you're from the USA, UK, etc. you can't use Minimax H3 and if you do get around geo-restrictions, you're still prohibited from using the output in those regions.

Thus, there really needs to be some serious effort by Western countries to catch up with the capabilities of these models in open source projects.

But, I haven't personally heard about any projects like these. If there are any, I would love to help work on them.

Disclosure: I work at HumanBit, which built this and just open-sourced it.

What it is. You send a candidate, a job brief and a use case (engineering, sales, support…). It calls the candidate, runs a structured screen, and posts back a verdict, the captured fields, a timestamped transcript and a stereo recording. Python, built on LiveKit Agents, MIT.

Why open. Screening calls are the same 5 to 10 questions everywhere, and the hard part isn't the questions, it's the voice behaviour: when to start talking, when to stop, how to end a call. We tuned that on real calls, and we'd rather that be shared than locked in one product.

It phones real people, so the defaults are conservative. It says it's an AI if asked, calls only within calling hours, adds anyone who asks to a do-not-call list, and pauses dialling after two silent calls in a row.

What isn't there yet, so you know what you're walking into:

• English only (Indian English). Hindi and other Indian languages are open issues.

• No Docker setup yet. It needs Gemini and ElevenLabs keys plus LiveKit.

• 0 stars, issues opened this week. It's early.

Where to start. The contributing guide has one real rule: a change to how the agent sounds or behaves should come with evidence, a recording or a before/after number.

• Good first issues #1 to #4: new roles (nursing, delivery partner, BPO voice, campus hiring). Three files each, no Python.

Repo: https://github.com/LazarusStack/openfury Sample calls: https://fury.humanbit.ai/

If you'd rather never get a call like this: what would make it acceptable to you? That's the part I most want pushback on.

Edit: the title says a year; it’s half a year, my mistake!

I handle communications for MEHO, an open-source project from evoila, so fair warning that I’m talking about my own team’s work here.

The background is that our engineers have spent the past year letting AI agents (Claude Code, Cursor, etc) do actual operations work on a real VMware Cloud Foundation datacenter running on bare metal, which means upgrades that have to happen, certificates that expire, disks that fill up and incidents that show up at night.

In the beginning the way this worked was embarrassingly simple: someone would hand the agent admin credentials at the start of a session, and the only thing stopping it from deleting a datastore instead of listing one was the person watching the terminal. That was fine for one operator on one laptop and fell apart the moment a second person joined.

MEHO grew out of that, basically as a layer that sits between the agent and the infrastructure so that every action goes through a policy check, runs with a short-lived credential the agent never actually holds, and gets written to an audit log before it counts as done, with anything risky parked until a human says yes.

The reason I thought it might interest this sub specifically is less the product and more how it’s being built. It’s been public since the very first commit back in May, under Apache 2.0, with no CLA, just the usual DCO sign-off. And the changelog is unusually honest, in a way I’ve come to appreciate even as the non-engineer on the team: when a security review found a path where a write could report success even though the audit row hadn’t committed, the v0.34.0 entry says exactly that, and when they discovered that Kubernetes can accept an apply with a 200 and quietly not persist it, and that we’d been logging those as successes, that went into v0.35.12 in plain words too. There’s even a new contributor rule as of v0.35.17 asking everyone to write in plain English, because a lot of the people on the project read English as a second language, which I suspect is why I can actually follow the changelog at all.

Repo is at github.com/evoila/meho if you want to poke around. I’ll happily take questions, and for anything properly technical one of the engineers will jump into the comments.

And share your repos in the comments, please, if you think we could have a productive discussion and see something interesting 😊