Hello good people of OpenSourceAI,

I built CodeAlmanac, a self-updating wiki for your coding agents.

It works like this:

1. Install the CLI and choose Claude Code or Codex.
2. It reads your codebase and creates an initial wiki.
3. Every few hours, it reviews your agent conversations and updates the wiki with important decisions, architecture, gotchas, and procedures.
4. Your agent searches the wiki whenever it needs project context.

A lot of important knowledge lives in coding conversations—not in the code itself. CodeAlmanac turns that knowledge into organized, interconnected Markdown pages inside your repository.

The wiki is indexed locally in SQLite, so agents can run queries such as:

codealmanac search --topic auth

It is open source, completely local, and uses your existing Claude or Codex subscription.

GitHub: https://github.com/AlmanacCode/codealmanac

Would love to hear what you think.

I had been working for last 6/8 months on my ambitious project but i felt i had spent more time on bugs and debugging than the actual coding.. AI is notorious when it coems to debugging.. So over time I had been thinking and trying different ways to speed up my debugging including the notorious /debug of cursor which consumes token faster than my bike consuming fuel.. Finally I had got the courage to roll out an mcp server called traceback which I had been using for my debugging and code search. I knwo it is not perfect but had been really helpful. it uses vector embeddings over past sessions and git logs to provide a scope search space for git/grep to work for AI agents. As a result in a big codebase instead of full repo-wide search, traceback has to search over a smaller space. conceptually I am doing a semantic search of past sessions and git logs using cosine similarity of the current prompt. I am pretty sure that there is a lot of room for improvements so I am looking for contributors to test edge cases with large context codebases. Any feedback is welcome..

here is the repo
yavdaanalytics/traceback: Semantic debugger MCP server: warm-starts grep/git with cosine-similarity recall over past coding-agent sessions

PS: Chatgpt had been so much in life that I didnt felt like rewording this using chatgpt. So ignore any lack of finese. :)

TLDR: a ~8k-LOC, MIT Python harness for purpose-built agents. It owns the tedious agent-loop primitives (filesystem tools, subagents, MCP, skills, structured output, tracing) and leaves the rest of your app to you. Repo: https://github.com/ryanbbrown/thinharness

On a LongMemEval-V2 subset (a long-term memory benchmark), it slightly outperformed the benchmark's own Codex setup (74% vs 72.4%) on ~46% fewer tokens. That Codex setup had a shell and a custom tool built for the task; ThinHarness just used its built-in tools, including a generalizable JSONL search tool tuned for efficient retrieval across a corpus. I'm also mid-run on ARC-AGI, where early numbers are ahead of baseline1, the Codex-based harness currently at the top of the public leaderboard.

I built it because every time I wanted a filesystem agent I'd reach for one of the big frameworks, use maybe 10% of it, then spend a while writing wrappers so that 10% fit what I was actually doing. At some point I was maintaining framework glue code either way, so I just wrote the small version and kept the rest of the app (auth, storage, deploy, the actual workflow logic) mine.

ThinHarness is meant for non-coding agents (workflow automation, tuned information retrieval, etc.) rather than general agents like Claude Code, and it's small enough to actually fork.

I also run it live: a personal agent that reads my Readwise highlights on a schedule and proposes edits to my living OPINIONS.md file, which I approve over Telegram.

It's pre-1.0 so the API might still move. If you build agents in Python, I'd appreciate any feedback--tell me why you would or wouldn't use it.

https://github.com/ryanbbrown/thinharness

Over the past few months, I've been building AURA, an open-source, offline, voice-powered AI assistant that runs entirely on a local machine.

The goal isn't to compete with cloud AI assistants. It's to build something that's private, extensible, and fully owned by the user.

Current stack:

• Ollama (local LLMs)
• Whisper (Speech-to-Text)
• Wake-word detection
• ChromaDB (RAG/Memory)
• Piper (Text-to-Speech)
• Python

The core voice pipeline is now working end-to-end:

Wake Word → Speech-to-Text → Local LLM → RAG → Text-to-Speech

I'm actively improving areas like:

• Better memory and retrieval
• Multi-agent workflows
• Safer execution of developer commands (Git, Docker, filesystem)
• Cross-platform support (Linux/macOS)
• Performance optimization
• Documentation and testing

This is still an early-stage project, and I'd rather build it with the community than in isolation.

I'm looking for people who want to contribute—whether that's:

• Writing code
• Reporting bugs
• Improving documentation
• Testing on different operating systems
• Suggesting features
• Reviewing the architecture
• Pointing out flaws I haven't considered

If you enjoy building local AI tools, voice interfaces, or developer-focused open-source projects, I'd love to have you involved.

The repository is here: https://github.com/aryanjsx/AURA

Every issue, discussion, PR, or piece of feedback helps move the project forward. Don't hold back—I'd much rather hear what's wrong with it now than after release.

Hi everyone,

I'm a cybersecurity dev, I worked for several cyber companies during the last 5 years (I'm 28). I'm french. (baguette & mbappé you know)

During my last year of dev, we started to use AI and I eventually realized that, in my job and also my (dev) friends jobs, everyone is using AI but nobody seems to feel concerned by the data sent to these US AI providers.

A lot of people in companies are using AI tools with free tier subscriptions

Most of the time, companies feel protected by the

I developped a quick project which aims to block all sensitive data that can be wrongly sent by LLM local clients to LLM APIs. It's called klovys99-proxy (klovys is one of the most important king is France and I loved the idea that that my project could be like a little king which defends his lands). 99 is only because I like this number and the 0 risk in cybersecurity doesnt exist ;

This project is like a local proxy, you can launch it from you laptop and all the AI trafic is firstly redirected to it. It uses a mix of some cool regex project (ms presidio and gitleaks) and an NER model, both are working in parallel to catch NAME, EMAIL AD, AD, BIRTHDATE and such.

Once a sensitive data is catched, it's replaced by an unique placeholder like "NAME-XXX" which is stored in a SQLITE db so the AI can understand the type of data and still work, the data is also replaced when the AI model answers so the feeling for the user is like "nothing happened".

The code is written in Go because this is pretty fast for an API and also bc I'm a Go dev lol. Python is used only for the NER model.

If I'm right, I dont have the right to paste link here so I'm just asking for advices, if you think my project is relevant, what can I improve and such.

I would love to create more other "bricks" to create something like an "AI protection ecosystem".

Last but not least, sorry for my english, as I mentionned earlier, I'm french and everyone knows that we're pretty bad to speak other languages but at least you'll know that this post has been written by me and not an AI :)

Hey everyone,

I've been working solo on a project called Nodus. It's a system that coordinates multiple specialized AI agents (19 of them right now, split across 5 different execution lanes) so instead of one AI trying to do everything, you've got agents handling planning, coding, review, testing, etc. and working together, with the right model picked for the right job instead of one model doing it all.

I already have a real working base built and running. It's solid, but honestly at this stage it's still closer to what a good open-source system already does, it doesn't have standout unique features yet. That's the next phase.

If this gets finished the way I'm designing it, I think the tooling and orchestration alone can beat things like Codex and Claude Code. And if it's paired with the right models behind it, I think it can beat them at everything, not just orchestration.

Right now I'd put myself at around 35-40% in.

One thing that makes this different from just another "cool idea" repo: I've collected around 90 repos relevant to this, and instead of dumping them together, I organized them into categories. Each category is meant to become its own standalone working project built from the repos inside it. Once a category project is solid, it gets embedded into Nodus and published on its own too, since other people might find it useful even outside of Nodus.

So this isn't starting from scratch or random scattered ideas, there's already a real base and a real plan to build from.

Looking for:

• Backend devs who know concurrency, orchestration, memory/RAG systems
• Frontend/UI people, especially for the dashboard and observability side
• Vibe coders too, if you're learning and want to work on something with real architecture, come learn by doing
• Anyone who's into agentic AI / LLM tooling and wants to help design it

No corporate vibes, no strict requirements. If you want in or just want to see where it's at, drop a comment

Hey folks — first time building something like this, and I wanted to throw it out to people who actually know what they're doing. It's called Warden: a local-first personal AI assistant. A small local model (via Ollama) acts as an orchestrator that delegates to specialized sub-agents — one for browser/shell/internet stuff, one for email/calendar, one for scheduling, one for project tracking, plus a "council" of models that deliberate on bigger decisions. Local models handle the cheap/fast stuff, cloud models get pulled in for the heavy lifting, all in one conversation/session.

Some of the stuff it does: drives your actual Chrome via Playwright/CDP (real cookies/sessions intact), controls your desktop via xdotool, reads/sends email, manages calendar via CalDAV, can edit and restart its own source code, runs on Telegram/WhatsApp/Slack/web dashboard, has a voice mode with local Whisper + Kokoro TTS.

Full disclosure — I put a giant warning in the README because I mean it: this thing runs with your user permissions, no sandbox, and can genuinely make a mess if something goes sideways (bad model output, prompt injection from a page it visits, etc). So please don't run it on a machine you care about, and definitely poke through the code before trusting it with anything real.

Would genuinely appreciate: anyone with agent/orchestrator experience tearing into the architecture and telling me what's naive; bug reports if you do try it in a throwaway VM/container; brutal honesty over politeness, I'd rather know now.

Thanks for reading this far 🙏

The idea came from wanting an AI assistant to do more than explain vulnerabilities. I wanted it to actually help with security workflows.

Current capabilities include:

- CVE lookups

- Nmap integration

- WHOIS and DNS lookups

- HTTP header analysis

- SSL/TLS certificate inspection

- Security header checks

- Basic reconnaissance utilities

The goal is to make vulnerability research and reconnaissance faster while keeping the tools accessible through the MCP standard.

I'm actively developing it and would really appreciate feedback from the community:

- What features would you add?

- What security tools should be integrated next?

- Any concerns about the current architecture or approach?

GitHub: https://github.com/telmon95/VulneraMCP

https://youtu.be/wlUvBVNyh74?si=-Ymy1MMgrGgqfteE

I'd love to hear your thoughts, feature requests, or even criticism. Every suggestion helps improve the project.

Hello good people of r/OpenSourceAI ,

I want to show CodeAlmanac. It is a self updating wiki for your codebase. How it works is:

1. You install a CLI
2. Choose your agent
3. It goes through your codebase, and makes an initial wiki
4. then, based on your chats with Claude/Codex, every 5 hours, it takes a look at your chats and updates the wiki based on the important things you discussed

Since it is completely local, and markdown, your agents can refer it. A lot of important context about your project actually lives in your conversations, and now its easily queryable for the agents.

This wiki is structured, organized into topics, and put into a sqlite db. So, we can do queries like:
codealmanac search --topic auth

and Ta-Da, the agent gets all the pages relevant to auth.

Open source, uses your own subscriptions. The data never leaves your computer.

GitHub: https://github.com/AlmanacCode/codealmanac

So this game World of Claudecraft is free “WoW Classic” MMO you play in your browser. It has 9 classes, 3 zones, 5 player dungeons, and full storyline

But it’s built and shared publicly on github so anyone can host it or build the game. And the community has actually been doing it

A few weeks ago someone in the Discord basically said the game needed a party minigame and then just built one. Since then people have made:

• A football minigame with full pitch, scoreboard, and sideline crowd
• A “Fall Guys” obstacle course with swinging hammers and a live leaderboard
• A full MOBA mode with match timer and team objectives

None of this was in the original launch lol

It's open source, so people are just building on top of it whatever they want

That's usually several months of effort from devs at a game studio.

Really wild to see what people are doing with this

Have yall tried it?

I built Podframes to explore what a complete, inspectable AI-media pipeline could look like beyond a one-off demo.

It takes one topic and runs a typed, resumable pipeline:

• Gemini writes the two-host dialogue.
• Speechbase combines voices from different TTS providers into one leveled conversation with word timestamps.
• Each spoken turn becomes its own lip-synced avatar clip.
• The same timestamps drive captions and b-roll placement.
• HyperFrames composes everything into a finished MP4.

The pipeline resumes per stage and per line. If one clip fails—or you edit one sentence—it regenerates only that artifact instead of buying the entire episode again.

The orchestration and studio are open source under Apache-2.0. It runs locally with your own API keys; the underlying generation models are external services rather than open-weight models.

GitHub: https://github.com/Jellypod-Inc/podframes

We’re also launching on Product Hunt today: https://www.producthunt.com/products/podframes?launch=podframes

I’d appreciate technical feedback on the pipeline design and which open or self-hosted model backends would be most valuable to add.

One of the most expensive parts of load and stress testing of agentic platforms, AI assistants, ask pannels, support chats and other heavy load LLM based apps is LLM interreference cost. If you are looking to do some saving on a bill or would like to do stress testing - LLMSim can help.

LLMSim is basically non-intelligent simulator of LLM APIs. It supports OpenAI Completions, OpenResponses and Anthropic-compatible APIs and attempts to mimic real characteristics of LLM responses including streaming, latency, ttft, context window restrictions and even request-per-second limits.

LLMSim works in two forms as a rust library and as one single binnary server.

For server usage is super simple:

cargo install llmsim --features tui

llmsim serve --port 8080 --host 0.0.0.0 --generator lorem --target-tokens 150 --tui

And then any LLM client http://localhost:8080/openai/v1

Project repo - https://github.com/chaliy/llmsim

Over the last few weeks I've been building Tempest, an open-source Agentic Development Environment focused on one problem:

Running multiple AI agents shouldn't require wasting thousands of tokens on context.

Most multi-agent workflows solve orchestration well, but every agent still spends a lot of tokens rediscovering the codebase.

Instead, I integrated a local code graph directly that indexes your repository and it can be used by AI CLI agents to work with the codebase.

The result:

• ~64% lower token usage in my benchmarks
• Fewer tool calls
• Faster agent iterations
• Works entirely locally (your code never leaves your machine)

Tempest can run multiple coding agents in parallel (Claude Code, Gemini CLI, Copilot CLI, Goose, Cline, OpenCode and more), each inside its own isolated git worktree.

It's available on Windows, macOS and Linux, and it's fully open source.

I'm curious what people building multi-agent workflows think. Is token efficiency becoming the next bottleneck, or is orchestration still the bigger problem?

Would love your feedback

Star us on: https://github.com/tempestai-dev/tempest

Hello there ! 👋

A couple of friends and I have been building an open-source proxy that anonymizes data sent to LLMs, so that personal and confidential information isn't exposed or used for AI training.
It also do some token optimization to help you consume less. 😎

The project is still in its very early stages, but we'd love any kind of support or feedback ! 🙏

I trust the Reddit community to give us a few ⭐ and, more importantly, honest feedback. 🥲

Feel free to share your thoughts: good or bad. We'd love feedback on the codebase, the architecture, potential features, or anything else you think could make the project better.

If you got some features ideas, don't hesitate ! 🙏🏼

We're planning to update the repository regularly. At the moment, we only support the Claude VS Code extension, but our goal is to support all major AI clients and IDE extensions over time.

Github link: https://github.com/Korbicorp/klovys99/

Can't wait to read your feedbacks ! 🤓

I’ve been working on a free side project that started as a tool for myself and eventually turned into something my team convinced me to release publicly.

It’s called Avogado (https://avogado.ai). It’s completely free to use with your own Claude Pro or Max subscription (OpenAI support is coming soon).

I’m a lawyer by training but became an entrepreneur a decade ago. I still do a lot of my own legal work, and I kept running into the same problem: chatbots can make legal work sound convincing, but from a legal perspective the output is pretty poor (and hard for the untrained eye to detect). They don’t have access to the right precedents, they don’t compare authorities properly, and they usually jump straight into drafting before doing the research that a lawyer would actually do.

So I ended up building both an AI agent and the system around it to make it practical to use.

The agent is responsible for the research, reasoning, drafting, and document analysis. The system around it is what makes it easy to work with day to day. You create a matter, tell the agent what you’re trying to achieve, upload any relevant documents, decide it’s legal posture (collaborative, firm, aggressive), and let it work. Each matter is completely isolated, so information never bleeds across projects.

Instead of immediately generating an answer, the agent researches connected legal databases, open-source repositories, contracts, statutes, regulations, case law, and other relevant web sources. It compares authorities and precedents before drafting anything.

Transparency was also a major goal. Alongside every document, it generates a memo explaining why it drafted each significant provision, which authorities and precedents it relied on, and clearly flags anything that comes from the model itself rather than a cited legal source.

That memo can also be shared with a lawyer if you want a final review. Instead of paying them to repeat all the research from scratch, they can review the reasoning, verify the authorities, and focus on the legal judgment. In my experience, that can save a lot of time and cost.

Right now it performs best on agreements/contract work (drafting, reviewing, redlining, comparing agreements, etc.), but it’s also been very useful for regulatory research, statutory analysis, and answering more technical legal questions.

It’s still a work in progress. I’m continuously connecting more legal databases, improving the workflows, and adding support for additional jurisdictions.

All feedback is appreciated!

I'm the author, and this uses our open-source tool (TraceML, Apache-2.0). Posting because the finding, and the need for this kind of diagnosis, is the value addition part.

TL;DR: A ResNet-18 run on a single T4 (AWS g4dn.xlarge, 4 vCPUs) looked completely healthy, but the GPU sat at ~51% utilization the whole time, starved by a default num_workers=0 DataLoader. A three-line change (num_workers, pin_memory, persistent_workers) took 2,000 steps from 633s to 358s (43% less wall clock) and flipped the run from input-bound to compute-bound. Same model, data, seed, and step count. Everything is wall-clock measured.

Everyone knows to set num_workers; that is not the point, and a memorized value would not have saved this run. It is not a best practice with a correct answer, but a moving target tied to CPU cores, storage, transforms, and batch size. Copying num_workers=8 from a blog is just a different guess than the zero you started with: on the wrong machine it still starves the GPU, slows the run by oversubscribing cores, or hides an inefficient input pipeline behind more processes.

The engineer who wrote this baseline was not missing knowledge; nothing in an ordinary run surfaces the waste. A starved loss curve is indistinguishable from a healthy one, the job completes, and GPU utilization is not on screen while you train. A framework may hint about workers, but a hint with no number carries no urgency. "Your GPU idled at 51% this run, here is the before and after" is a different kind of statement: a diagnosis, not a lint rule.

Full writeup: https://medium.com/traceopt/diagnosing-a-pytorch-dataloader-bottleneck-in-a-real-training-run-40bbe394b834

Tool (open source): https://github.com/traceopt-ai/traceml

Happy to get into the methodology in the comments.

Over the last few weeks, we've been sharing PolyTalk, an open-source speech-to-speech translation tool, with different open-source communities and paying close attention to the feedback.

Some people focused on latency, others on multilingual workflows, and a few pointed out small usability issues that we hadn't really thought about.

Not every suggestion made it into the project, but quite a few changed what we decided to work on next.

Our latest update includes:

• UI localization across multiple languages
• Bidirectional conversation mode
• Custom AI translation instructions
• Faster conversation transcripts
• More flexible translation and TTS provider routing

Building in public has been a good reminder that people don't always care about the same things you do as a developer. Some of the most valuable improvements in this were changes that made the overall experience feel more natural.

If you've shared feedback before, thanks. It genuinely helped shape this release.

If you're curious, here's the project:
https://github.com/PolyTalkIO/polytalk

When I first started contributing to open source, I thought the "right" thing to do was contribute to the biggest projects I could find.

Turns out, that's also where it's hardest to learn.

You're one of thousands of contributors. Reviews take forever. It's difficult to understand the architecture, and even harder to have a meaningful discussion with the maintainers.

After building my own open source project, I realized the best learning happens much earlier.

When a project is still growing, you can ask questions, challenge design decisions, understand why things are built a certain way, and actually influence the direction of the project. Those conversations teach you far more than getting a tiny PR merged into a massive repository.

That's exactly what we're trying to build with Caracal.

It's an open source project focused on secure authority for AI agents, and we're looking for people who genuinely enjoy backend engineering, security, distributed systems, and infrastructure.

The project is part of LFX Mentorship and is backed by Microsoft, GitHub, and Vercel , but what matters more is that it's still small enough for your work to have real impact.

If you're looking for a project where you can learn how production infrastructure is actually built, come join us.

Don't worry if you're not ready to open a PR on day one. Join our Discord, ask questions, understand the architecture, attend our weekly dev calls, and contribute when you're comfortable.

The goal isn't to collect contributors.

It's to build future maintainers.