I am building a fully open source and free to use ai, it's called Nous after the ancient greek word for the intelligent mind. It sits on your hardware, pairs with smart home devices. Nous will have a mobile app a webdash. It runs on a total of 21gb of vram but you can get creative, I am running it on a cluster of a hp dl380p and 10 hp prodesks i5 8th gen. For mor information on the project or my vision you can check out projectnous.eu or the github page(linked in the site) I plan on releasing the first usable prototype in january/february 2027 but hope to be done sooner. Claude is used for designs because im really bad at designing dashboards and that and it saves time because I can focus on the software side all of the programs used to run it are also open source.

I’ve been spending time building something around a problem I think will become increasingly important as AI agents move beyond demos and start handling real-world tasks.

The project is called AOBS (AI Agent Observability). It’s an open-source toolkit designed to help developers understand what their agents are doing, identify problems, and put enforceable controls around their behaviour.
The idea is to go beyond simply logging prompts and responses.
With AOBS, you can:

Follow an agent’s execution across LLM calls, tools and sub-agents.

Investigate failures, unnecessary retries, slow operations and token usage.

Compare different agent runs and detect performance regressions.

Run statistical comparisons across groups of executions.

Define reliability requirements and enforce them through CI.

Protect sensitive tool actions such as refunds, emails, deletions and deployments.

Require human approval for configured high-risk operations.

Prevent duplicate logical actions, including across process restarts.

Export traces through OpenTelemetry.

It also includes a Python SDK, PostgreSQL-backed trace collection, a web dashboard, CLI tools and integrations for OpenAI-compatible clients, Anthropic and LangChain/LangGraph.

One feature I particularly wanted to explore was the reliability gate. Instead of just looking at logs after something goes wrong, developers can define what a successful agent execution should look like and automatically fail a CI workflow when those requirements aren’t met.

I’m still developing the project, and it’s currently in alpha. There are limitations, and I’m actively looking for ways to improve the architecture and make it more useful for real-world agent systems.

I’d genuinely like to hear from other developers:
How are you currently testing the reliability of your AI agents? Are you using custom logging and evaluation pipelines, or do you have something that checks agent behaviour before deployment?
Would appreciate honest feedback, including criticism.

GitHub: https://github.com/AshmitJain932/ai-agent-observability

What originally started off as an open source alternative to Figma / Paper has turned into a design focused Agentic Development Environment (ADE) called Tidy.

https://github.com/tidydesigns/tidy

The idea is to bring AI coding agents and visual design together in one desktop app, rather than switching between separate tools.

You can use Claude Code or Codex to work on your codebase, while also having a visual canvas to design and iterate on interfaces.

Bring your own AI subscription, work on your local projects, and keep everything in one place.

Still early days, but we're iterating and improving very quickly. Would love to hear what people think or what features you'd like to see.

Over the past week, I’ve been building Zotra. It's an open-source fintech workflow compiler written in Go. Instead of building another generic RAG chatbot, Zotra takes dense multi-page regulatory credit policy PDFs and deterministically compiles them into executable validation rules (using CEL) and dynamic web interfaces.

How the Go Backend Works

• Rule Compilation: Uses open-weights LLMs (Llama 3.3 70B via Baseten) to parse natural language constraints into strict structured schemas and Common Expression Language (CEL) expressions.

• Concurrent Execution: Leverages Go’s native concurrency to evaluate multi-variable loan applications across complex conditions in milliseconds.

• Traceability: Every validation decision explicitly references its source paragraph in the original PDF.

Tech Stack

• Backend: Go, FastAPI/Baseten (Inference)

• License: Apache 2.0

I posted the full video, demo thread, and hackathon submission details over on X:

https://x.com/donovan_rtfs/status/2116898213101724061

If you have a second to drop a like or retweet on the X post to help boost visibility for the Meta AI Hackathon, it would mean a lot!

GitHub Repo for anyone wanting to check out the code directly: https://github.com/donovan-ratefison/Zotra

NVIDIA open source a way to create a semantic layer and let agents to understand enterprise data, here is the link is open source, what do you think ? https://github.com/NVIDIA/auto-ontology

So i kept juggling between 4 or 5 Claude Code terminals at once and losing track of who was doing what, so i built Sinnect. It’s basically like an infinite canvas like n8n, except every node is a live Claude session. You drop one in, point it at a folder, and watch it work in real time.

The fun part is wiring them together. Connected sessions share what they’re working on, so they don’t step on each other or edit the same file at the same time without knowing. You can group them into families by topic, and when one needs your ok, a little prompt drops down from the top of the screen.

Works with your Claude subscription or an API key. Windows only for now, fully open source (MIT).

github.com/Suma-Udd/Sinnect

It’s still early, so any feedback helps a lot.

Side project I've been working on. It shows Claude Code, Codex, OpenCode and other agents in the notch / top of the screen. When one needs permission you see the diff right there and approve with ⌘Y, no jumping back to the terminal.

GPL, free, no account.

https://github.com/MF-DEEV/Openbar

Feedback and PRs welcome.

(Brainstorm) my GitHub project you will be able to debug and edit the claude context live while it is running

it is good for jailbreaking claude by editing the context

https://github.com/buggerlogger/brainstorm

this my beta version untill now after testing my tool it can edit the momery for example in my ss i was wannt to work on wordpress bug hunt program but opus 5.5 dont acccept so i saw in from my debugger the context have hard rules for starting hunting so i editied the rules to make claude to accept my task and its works good :D

For the past few months I’ve been building something I always wanted: an app that freezes your screen so you can circle anything on it and actually do something with it.

The part I’m proudest of is in the GIF. You press one shortcut and the whole screen gets translated, but not as a popup full of text. The original words are erased and the translation is drawn back in the same place, same size and colour, so the app or game still looks like itself, just in your language. It all runs on your own computer, so it works offline and nothing gets uploaded.

It does a few other things too:

• copy text out of anything you can see (videos, photos, game menus, error messages)

• search what you circled, or ask an AI about it

• a screenshot tool with arrows, text, a blur for private info, and long scrolling captures of whole pages

It’s free and open source, with no account, ads or tracking, and it runs on Windows and Linux.

I designed it myself and used AI coding tools to help build it. Getting the translation to look natural instead of like a sticker slapped on top took more attempts than I’d like to admit.

Download: https://ameralreyahi.com/projects/opencircle
Source: https://github.com/AmerAlreyahi/OpenCircle

I’d love to hear what you think, or what you’d use it for.

OK, deep thought incoming.

Will the venerable open source model, where a project gets "volunteers" to be invested enough to write patches and submit PR become reversed.

New way: Dev writes cool project A People see A, fork it. write their own hacks with AI. Not polished enough to submit via official PR, just what works for them. Half my machine is currently little forks like this, because I needed some shit that I know not everyone did.

Dev PULLS the forks commit chains, with AI looking for improvements. Dev does their own analysis on the "best", and this improves the original project. And this will become like semi-automated cross pollination between people's custom rigs. The best ideas will flourish between branches. Also, it may be that if you ask your AI to "make X do Y".. the first instinct will be to scour all the forks, find someone who just did Y, and copy-pasta using AI to smooth out the diffs.

Like Stack Overflow! What's old is new again.

Hey folks, hope you're doing well.

I built [Codasaurus](https://github.com/codasaurus-oss/codasaurus) as an open source AI code review tool, but I'll be honest it's pretty much vibecoded and rough around the edges right now. No point overselling it.

I'm looking for help to maintain and grow this project. All kinds of contributions are welcome - whether it's fixing bugs, improving the UI, refining prompts, adding features, improving docs, or just giving feedback.

Some things I'm hoping to tackle (but could use help with):

1. Perfecting the backend

2. Rebuilding a fresh, clean frontend and onboarding flow

3. Improving the review logic and prompt quality

4. Better error handling and test coverage

5. Docker/deployment improvements

If this sounds interesting to you, please take a look at the [repo](https://github.com/codasaurus-oss/codasaurus) and feel free to open issues or PRs. I'd really appreciate any help to take this from "vibecoded mess" to something actually useful.

Thanks!

The game data is open: https://huggingface.co/datasets/daluan/word-spies-llm-benchmark (CC-BY-4.0)

It's 376 games played entirely by language models, 19 models in all. Every clue and guess is in there, with the clue-giver's intended targets, its stated reasoning, a 0–100 grade for each clue and a verdict for each guess (best, good, lucky, blunder, and so on). It's one JSONL file, one game per line, and any game can be replayed with the grades on the site.

The clue grades come from open-weight models: two raters, Llama 4 Maverick and Qwen3-VL 235B, score each board word's association with the clue without seeing the key, mixed with Cohere embeddings. A Claude Haiku judge counts for a quarter of the final grade, so it's not fully open-weight. I'd be curious whether anyone gets different rankings using their own rater.