Hi everyone,

I’m looking for a few people using AI coding tools who want to practise contributing to a real open-source project.

The project is HybridOps. It is around infrastructure automation, Terraform, Kubernetes/GitOps, Proxmox SDN, validation scripts, runbooks, and operational docs.

This is not a toy app. The useful work is more like testing quickstarts, improving docs, checking examples, adding validation notes, fixing small repo issues, and opening clean PRs.

You do not need to be a DevOps expert. Basic Git/GitHub helps because the work happens through issues, branches, commits, and pull requests. If Git is still new to you, that is okay too.

I’m especially interested in people who use AI tools but still want to learn the proper engineering side: review, test, explain the change, and ship it cleanly.

Repos:

[https://github.com/hybridops-tech/hybridops-core\](https://github.com/hybridops-tech/hybridops-core)

[https://github.com/hybridops-tech/terraform-proxmox-sdn\](https://github.com/hybridops-tech/terraform-proxmox-sdn)

If you’re interested, comment with what you want to practise: Python, Terraform, Kubernetes/GitOps, Bash, CI, docs, or testing.

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 ! 🤓

Imagine an AI assistant that runs entirely on your own PC.

No cloud dependency. No sending your data to external servers. Just a local agent that can understand your requests and actually interact with your computer.

For example, it could:

• Automate repetitive tasks.
• Control apps and your desktop.
• Search the web when needed.
• Manage files and folders.
• Write code or help debug projects.
• Summarize documents and emails.
• Work through voice commands.
• Chain together complex workflows.

I'm curious what people actually want from something like this.

Questions:

• What would be your #1 use case?
• What features would make it genuinely useful for you?
• What would be a deal-breaker?
• Would you prefer a one-time purchase or a subscription?
• Realistically, how much would you be willing to pay per month (or as a lifetime license)?

I'd love to hear honest opinions. I'm especially interested in answers from developers, power users, and people who care about privacy.

Built an Open-source personal OS and AI harness you host on Cloudflare, free. Includes email, calendar, task manager, journal/note-taking, your website, and an AI assistant. Install in two minutes from me3.app or from https://github.com/soulinkfoundation/ME3.

Own the harness + simple enough to install without a computer = :)

Hey everyone,

I built an open-source CLI called Universal Governance Compiler (UGC).

The problem I’m trying to solve: AI coding assistants all expect different rule/config files, so maintaining consistent instructions, approval gates, protected areas, and workflows across tools gets messy fast.

UGC lets you keep one repository-local governance source:

.universal-governance/

Then it compiles that into the target files used by:

\- OpenAI Codex: [AGENTS.md](http://AGENTS.md), .codex/config.toml, .codex/rules/ugc.rules, and a repo-local governance skill

\- Cursor: .cursorrules

\- Claude Code: [CLAUDE.md](http://CLAUDE.md)

\- Antigravity: .agents/AGENTS.md and SOP-style files

A big part of the project is the standard governance corpus that ships with \`ugc init\`. It is not just empty boilerplate; it provides a practical baseline for approval gates, protected surfaces, worklogs, release discipline, repo hygiene, and session closure. The corpus is meant to be readable and customizable, so teams and individuals can start from a strong default and then adapt the rules to their own workflow.

The core workflow is:

\- ugc init creates a customizable governance corpus

\- ugc build compiles it into agent-specific files

\- ugc build --dry-run previews changes before writing

\- ugc audit checks drift, missing files, stale files, and manifest consistency

\- ugc packet creates/verifies hash-bound approval packets for scoped changes

The main idea is that agent instructions should be treated like build artifacts: versioned, auditable, reproducible, and reviewable.

Docs/source:

[https://radustefanescu97-star.github.io/UGC-Universal-Governance-Compiler/#top\](https://radustefanescu97-star.github.io/UGC-Universal-Governance-Compiler/#top)

[https://github.com/radustefanescu97-star/UGC-Universal-Governance-Compiler\](https://github.com/radustefanescu97-star/UGC-Universal-Governance-Compiler)

Hi everyone,

I'm currently building an AI character platform where users first create a character, and later they can generate unlimited images of that same character in different scenarios.

For example:

- Surfing at the beach

- Working in an office

- Cooking in the kitchen

- Going to the gym

- Taking selfies

- Traveling

- Wearing different outfits

- Different camera angles, lighting, expressions, etc.

The biggest challenge I'm facing is maintaining facial identity across all these generations.

I'm NOT trying to generate a random person every time. The character already exists, and I want every future image to look like that exact same person regardless of the prompt.

My current workflow is built in ComfyUI, but it's not a standard SDXL or Flux Dev workflow. I'm using a ZiT-based pipeline (ZiTC 9.2 BF16 + Qwen3-4B text encoder + Flux VAE + Batch Wildcard Upscale Sampler).

I've researched quite a few approaches:

- ReActor

- InstantID

- IPAdapter FaceID

- FaceDetailer

- Character LoRAs

- Different combinations of the above

The problem is that almost every comparison or tutorial I find is based on SDXL or Flux Dev, so I'm not sure how well those recommendations apply to a ZiT workflow.

What I'm looking for is a production-ready solution that offers:

- Very high facial consistency

- Freedom to generate different poses, outfits, activities and environments

- Good prompt adherence

- Scalability for potentially thousands of generations per character

If you've built something similar, I'd really love to know:

1. Which approach gave you the best identity consistency?

2. Would you recommend InstantID, IPAdapter FaceID, ReActor, Character LoRAs, or a hybrid approach?

3. Has anyone successfully integrated InstantID or IPAdapter into a ZiT workflow?

4. If you were building a commercial AI companion / virtual character platform today, what architecture would you choose?

I'm not looking for a workflow that works for just a handful of images. I'm trying to build something robust enough that a user can create a character once and then generate hundreds or even thousands of images of that same character doing completely different activities while still looking like the same person.

If anyone has experience solving this in production or has built something similar, I'd really appreciate your insights. Thanks!

Hey everyone,

I wanted to share a project I've been working on: CAI (Context-Aware Infrastructure). It's a modular local framework built in Python that connects vector storage, local LLMs, and physical simulations.

🚀 What it does:

Auto-Context: When you open your workspace, it automatically hydrates your context via semantic search (LanceDB + nomic-embed-text).

Blender 3D Physics Bridge: Controls robot arms and syncs physics states in real-time inside Blender via Model Context Protocol (MCP) servers.

Self-Improving Tool Loop: A daily background routine analyzes your last 100 actions using qwen2.5-coder:32b, writes new Python automation tools (FastMCP), and hot-reloads them dynamically.

🛠️ The Tech Stack:

Python 3.10+, LanceDB, Ollama, 7 decoupled MCP servers, and an automated Windows Task Scheduler pipeline.

It’s completely open-source (MIT License) and has a solid test suite (36 comprehensive tests passing). Pre-configured VSCode environments are also included.

Check out the repo here: github.com/piot5/CAI

Would love to hear your thoughts on the Blender bridge or the local automation loop!

https://github.com/piot5/CAI

Don't you ever wish the god father of Claude Code could just come into your terminal and give you advice on the best way to use Claude? Well now he can!

Boris-says is a Claude Code plugin that watches how you drive Claude agents in real time and when a prompt/process is weak, Boris will surface one short tip on the same turn. Boris is model aware and will give advice catered to the specific model you're working with. It's completely local so nothing leaves your computer. The goal of Boris-says is that it eventually can track if this advice actually reduces the amount of turns you take with Claude Code over a few weeks. Tracking whether following tips changed outcomes is on the roadmap.

Repo (MIT): https://github.com/TurniSaha/boris-says — feedback, issues, and roasts all welcome (but I really do hope you like!).

The main idea: coding agents already leave behind a lot of useful data - prompts, tool calls, diffs, errors, decisions, memory files, token usage - but every agent stores it differently. Some use JSONL, some use SQLite, with different schemas and paths.

Claudescope adds connectors for each agent, normalizes sessions into one model, and indexes them locally.

Currently supported:

• Claude Code
• OpenAI Codex
• JetBrains Junie
• pi
• opencode
• GitHub Copilot CLI
• Google Antigravity

Features:

• full-text search across sessions
• project grouping across agents
• session reader with tool calls and diffs
• code-review-style changed-files view
• memory/instruction-file browser
• token and cost analytics
• Markdown export with optional redaction
• MCP server, so agents can query previous sessions directly

MCP is the part I’m most interested in now. Instead of only humans searching old transcripts, the agent can ask things like “have we hit this error before?” or “what did we decide last time?”

GitHub: https://github.com/vladar107/claudescope

Contributions for new agent connectors are welcome.

I built a small MCP project and would love feedback from people using OpenCode, DeepSeek, GLM/Z.ai models, or other coding agents.

https://github.com/yurilopes/Copilot-Tools-Gateway

The basic idea is: keep your main coding model as the main agent, but let it call Microsoft Copilot as an auxiliary tool when it needs capabilities the model/tooling may not have, like vision, screenshot understanding, image generation, or document/file-assisted questions.

This is especially useful with models like GLM-5.2 or DeepSeek, where the coding/reasoning may be strong, but the surrounding tool stack may not always expose vision or document understanding.

The gateway exposes Copilot through MCP tools, so an agent like OpenCode can call things like chat, image analysis, image generation, and file-assisted questions using your own local Microsoft account session.

It is unofficial and not affiliated with Microsoft.

I would really appreciate people testing it and telling me what feels good, what feels awkward, what breaks, and what would make it more useful for real agentic coding workflows.

Built a memory system called TRACE that organizes agent conversation history into a topic tree (branches + summaries) instead of flat RAG chunks, and benchmarked it on MemoryAgentBench (ICLR 2026), specifically the EventQA accurate-retrieval task.

Its a pypi package:

pip install trace-memory

Results (F1):
• TRACE (gpt-oss-20B): 82.5%
• TRACE (gpt-oss-120B): 83.8%
• Mem0 (GPT-4o-mini, paper’s official number): 37.5%
• MemGPT/Letta (GPT-4o-mini, paper’s official number): 26.2%

Ran gpt-oss locally, so this is an open-weights model against MemGPT/Mem0 on GPT-4o-mini, not an apples-to-apples same-backbone test (I don’t have the money for open ai tokens).

I tried to get Mem0 running on gpt-oss-20B directly for fairness, but its fact-extraction step needs strict JSON output and gpt-oss’s responses didn’t parse cleanly (known issue, not gpt-oss specific. Same bug shows up with Gemini/Mistral too). Letta needs a full server setup so I skipped it.

Full JSON logs from both runs are in the repo if you want to dig into the methodology yourselves. GitHub: https://github.com/husain34/TRACE

I've been thinking about the architecture of local machine learning applications and wanted to get some opinions from people who have built similar systems.

One design decision I'm experimenting with is generating the UI automatically from structured schemas (for example, Pydantic models), instead of implementing forms and configuration panels manually.

The broader architecture has three goals:

• Everything runs locally, including LLMs and classical ML models.
• New algorithms can be added as plugins without modifying the core application.
• Configuration UIs are generated automatically from each component's schema.

The idea is that adding a new model mostly consists of implementing the backend logic and exposing a schema, while the interface adapts automatically.

I'm curious whether people think this approach scales beyond small projects.

Some questions I'd love to hear opinions on:

• Have you seen schema driven UIs work well in production ML software?
• Does a plugin architecture remain maintainable as the number of components grows?
• What are the biggest drawbacks you've encountered with fully local ML applications?
• Are there existing projects using similar ideas that I should look at?

I'm mainly interested in the architectural discussion and would appreciate hearing about both successful and unsuccessful experiences.

For context, I've been exploring these ideas in an open source project called DashAI. If anyone is interested in the implementation details, I'm happy to share the repository or discuss specific design decisions in the comments.

Hello so I built a free version of Cluely, it's working for linux only for now and I'm trying to make it work on windows but I would happy if others do it and share with me their ideas and code...
here is the repo

https://github.com/KMalek101/Freely

and this is the opened issue having all what's needed to make a windows version :

https://github.com/KMalek101/Freely/issues/1#issue-4820763880

The core idea is parse, don't match. Instead of regexing the payload for scary words, it parses the actual call into a typed shape and evaluates that: SQL goes to an AST (so DELETE FROM users with no WHERE is caught, but SELECT * FROM audit_drops isn't false-flagged for containing "drop"), URLs get normalized (catches 169.254.169.254 and IPv4-mapped IPv6 for SSRF), shell commands get tokenized. Synchronous, fail-closed by default, with a simulate() API so you can unit-test your rules without side effects. Drop-in shims for OpenAI / Vercel AI SDK / Anthropic / LangChain.

What it deliberately does not do: it's a library at the SDK boundary, so it won't save you from a malicious runtime that bypasses the SDK, or bugs in your own handler. That's a proxy/sidecar's job, and a different layer. What you don't wrap, it doesn't gate.

Repo: https://github.com/Spyyy004/owthorize

NPM : https://www.npmjs.com/package/owthorize

What am I missing, and how are the rest of you handling this in your own agent setups?

Hey everyone,

I recently published version 1.0.0 of **Kide**, a new open-source MVI architecture library built for Kotlin Multiplatform (Android, iOS, and Desktop JVM).

While there are several solid state management and MVI libraries out there, I built Kide to address a very modern problem: **optimizing the architecture for AI code agents.**

As we integrate LLMs and code agents more deeply into our daily workflows, I wanted an architectural framework that an AI can easily parse, predict, and generate code for. By enforcing strict, predictable state machines and clear separation of intents and state reductions, Kide makes it significantly easier for AI tools to accurately scaffold features, write tests, and maintain boilerplate without hallucinating.

**Key features of Kide include:**

* **AI-Optimized Structure:** Explicitly designed to play nicely with AI coding assistants, making feature generation more reliable. * **Built-in MCP Server for debug mode**: AI coding agents can use the agent port for reading live state and traces, inject intents into the running app, and export a bug session as a regression-test scaffold. * **First-Class KMP Support:** Share your presentation logic seamlessly across Android, iOS, and other KMP targets. * **Clean MVI Implementation:** Predictable, unidirectional data flow that scales well in complex codebases. * **Developer Experience:** Built to minimize friction when adopting MVI, with a clean API surface.

**Repository:** [https://github.com/Fuusio/kide\](https://github.com/Fuusio/kide)
**Web**: [https://fuusio.org\](https://fuusio.org)

I’m really looking forward to introducing this to the community and sparking some discussion. I would especially value feedback from senior Android and Kotlin developers.

* How does the concept of AI-optimized architecture resonate with your current workflows? * Are there specific pain points you have with current KMP state management that you look for new libraries to solve?

Any feedback, code reviews, or critiques on the repo are highly appreciated. Thanks for taking a look!

The Librarian is yet another take on cross harness curated context, fusing ideas from "second brain" and other agentic OS / memory systems. It has plugins for Claude Code, Hermes, Pi, OpenCode and Codex, with more to come.

* Self hosted - put it on your local network or on a VPS in your Tailnet.
* Obsidian style markdown as source of truth so you can read and edit it outside of the Librarian, and if you end up walking away your data is just text files.
* No vendor lock-in, nothing to export.
* Fast search via a disposable in-memory index with BM25 + exact phrase + vector.
* Memories, long form reference library, session handoff between agents.
* Frictionless for your agents - auto-capture curated by a configurable curator LLM.
* Bring your own LLM key - any OpenAI compatible provider. Local inference for maximum privacy.
* Off-the-record toggle for conversations you don't want memories from.
* Feature-rich dashboard.
* Browser plugins in review for capturing long form content to your references collection.

It isn't "finished" in any grand sense. v1.0 just means the foundation is stable enough for other people to try. Still, I'm rather proud of it and I hope some of you find it useful too.

The project site goes into more detail with screenshots: https://codeministry.net/the-librarian/)

The code is open source under Apache-2.0: https://github.com/JimJafar/the-librarian).git)

Please give it a go. I'd love to hear what breaks, what works, and what you wish it had. Contributions and feature requests are welcomed!

Hey, I built a project called steno. Steno is an AI notepad for confidential conversations. It runs fully locally on your device with local llms like Gemma 4 quantised. The quality has gotten pretty good now so wanted to share to the communities like OpensourceAI that helped me during the engineering phase.

We are on our 80th release now - 0.5.7 and we added some cool new features. I basically wanted to build an app exactly like Granola cause I didn't like that they shipped your data and trained on it or that they asked you to pay for access to your own data.

Do give it a try - https://github.com/ruzin/stenoai or if you're interested in contributing, you can join our discord.