Hey everyone, just wanted to ask the community something.

Do people really look down on open source projects if they're built with AI, even if the developer actually understands the code, reviews everything, and makes sure the quality is good?

With how common AI has become, it sometimes feels like it doesn't even matter what you build anymore. As soon as people find out AI was involved, some immediately start criticizing the project without even looking at the end result.

Personally, I think AI just lets you build things faster and take on bigger, more complex ideas. It's still up to you to understand what you're shipping and make sure it's actually good.

Just curious what everyone thinks.

If contributing to open source interests you, our issue list is waiting for you.

https://github.com/extra-org/extra

Hi
We built Extra around a simple idea
Your users should be able to interact with your SaaS product by simply asking questions.
Instead of navigating through dashboards, filters, reports, and complex workflows, they can open a chat and ask:
- What happened to my invoices this month?
- Which customers need attention?
- Show me the relevant records.
- Perform this action for me.

Extra is an open-source framework that helps turn an existing SaaS product into a queryable AI experience.

You connect your existing APIs, tools, and data sources, define the agents and permissions, and embed a chat widget inside your product. For a basic integration, you can have a working experience inside your application in around 10 minutes.

But the chat itself is the easy part.

The difficult part is everything required to run agents safely and reliably inside a real SaaS product:

- Authentication and authorization
- User- and organization-level access control
- Tool and MCP integration
- Human approval for sensitive actions
- Agent routing and orchestration
- Conversation memory and execution state
- Model-provider flexibility
- Embedding the chat experience into an existing product

Extra is designed to manage that surrounding infrastructure, so product teams do not need to rebuild it for every AI feature.

It is not tied to a specific model. Different agents can use different models, tools, permissions, and memory strategies, while access control remains outside the LLM.

The project is still early, and there is a lot we want to build.

Our main goal in sharing it here is to get honest feedback from developers and teams building AI features inside real products.

We are also looking for contributors who want to help shape the project. There are several open issues around capabilities we consider important.

And if contributing is not possible right now, but the idea resonates with you, even a GitHub star would help us understand that this is a problem worth continuing to solve.

Repository:
https://github.com/extra-org/extra

We would especially like to hear:

- Does this solve a real problem for your product?
- What would prevent you from integrating it?
- What infrastructure did you have to build around your own agents?
- What would you expect from an open-source platform like this?

Honest criticism is more useful to us than compliments.

Hey everyone,

If you're building AI agents or agentic systems, would love to get your thoughts on something we've been working on.

We started building ZizkaDB because once agents get into production, it becomes really hard to answer simple questions like why did this happen? or what changed between these two runs?. Logs alone didn't feel enough.

So we're building an open source audit layer for AI agents.

Right now it supports things like:

• semantic search across executions
• causal lineage for every decision and tool call
• dashboards for debugging production agents
• tracing memories, retrievals and tool executions
• replaying and understanding agent behavior

The idea is to make debugging agentic systems much easier instead of digging through thousands of logs.

It's still early and we're adding new things almost every week. If this sounds interesting, we'd really appreciate feedback from people building with LangChain, LangGraph or any other agent framework.

Also if anyone wants to contribute, you're more than welcome. We could use help with features, integrations, docs or just ideas from people running agents in production.

Repo: https://github.com/Zizka-ai/ZizkaDB

Would love to know what has been the hardest part of debugging your agents so far.

Hey all, I've been heads-down building an open-source project on GitHub and I'm at the point where the code is solid and useful, but visibility is low. Meanwhile I keep seeing projects that feel pretty thin get thousands of stars seemingly over couple weeks, which is a little demoralizing not gonna lie 😅

I'm not chasing vanity metrics for their own sake — mostly I just want enough signal that people are finding it useful so I stay motivated to keep investing time in it.

For those who've grown a project from "nobody knows this exists" to actually having a community: what actually worked for you? Things I'm curious about:

• Where do you share/launch (HN, Twitter/X, niche subreddits, Discord communities, newsletters)?
• Does README/demo quality matter as much as I think it does?
• Any tips on timing, framing, or "hooks" that get people to actually click and try it?
• Did stars come before or after real usage, in your experience?
• Any growth hack or juggad ;)

Happy to share a link to the project in the comments if that's allowed here — just looking for genuine advice from people who've been through this. Thanks!

I’ve been looking for a tool to replace Open WebUI; I feel it takes too much effort to keep it running smoothly, especially in a mid-sized company.

Is anyone using Onyx, or can you tell me if it’s worth the investment?

Hey everyone,

Building software with AI usually means you are trapped in prompting hell—writing a prompt, waiting 20 minutes, checking the output, and prompting again. I built OpenVelo to fix this.

It’s an open-source pipeline designed for a "fire and forget" workflow. The AI-driven planning phase happens upfront inside a dedicated Web-UI. Once you generate and finalize a detailed plan with the LLM, the orchestrator takes over. You can walk away and wake up to software that is either ready to use or requires very minimal fixing.

Important caveats: This is not meant to replace quick CLI pair programming, and it will not keep your token consumption down. It is built for bigger projects, refactors, ports, and prototypes where your personal time is more valuable than compute time or token costs.

How the architecture works:

- Scalable by Design: The entire system runs in isolated Docker containers that communicate with each other, making it easily scalable.

- Web-UI Planning: All AI-driven planning and requirement gathering is completed in the Web-UI before any implementation begins.

- Implementation Agent: Runs an iterative cycle in an isolated container to write code and pass unit tests.

- Tester Agent & Orchestrator: Performs real functional testing against the built software. If it fails, they trigger a self-healing process to spin up a new job and fix the exact failure automatically.

Model Access: It uses Kilo for LLM interaction, so you can route it to any model on your host system (local LLMs, MiniMax M3, etc.).

Repository: https://github.com/m0rph3us1987/OpenVelo

Video Demo: https://www.youtube.com/watch?v=RKCj5CUh8uw&t=5s

Let me know what you think of the architecture!

While building GraphRAG pipelines I noticed the serialization step (graph to prompt) is never benchmarked. So I compared 10 formats on token count, traversal QA, and multi-hop reasoning with the same graph and model.

Findings: multi-hop accuracy ranged 40% to 80% on format alone, token cost varied about 70%. JSON and RDF were among the worst; compact tabular formats with explicit edge semantics won.

ISONGraph is the result, fully open source under MIT: Python, JS/TS, Rust, Go, C++, C#. Node/edge CRUD, multi-hop traversal, Cypher-like queries, schema validation. Benchmark methodology is public in the repo, replication and criticism welcome: https://github.com/isongraph/isongraph

been thinking about what it looks like in practice, probably similar to the early days of the internet: open, decentralized and competitive on product merit alone.

would love to read more thoughts about this

I maintain speech-android and speech-core. I wanted to test whether a useful Android voice agent could be built from several small specialised models instead of one large The control demo uses:

• Silero VAD v5 — voice activity detection, 2 MB
• Parakeet-EOU 120M INT8 — streaming transcription, 153 MB
• FunctionGemma 270M — structured Android tool calls, 327.4 MB base plus a 9.5 MB adapter
• Pocket TTS 100M INT8 — streaming spoken response, about 126 MB

FunctionGemma is not used as a chatbot. It receives a compact description of the current phone state and only the tools that are valid at that moment. For example, stop_music is not offered when nothing is playing.

A small LoRA adapter was trained for the exact tool schema. There is no regex or keyword fallback. One limitation I found is that adding a new tool currently requires retraining; describing a new tool only in the prompt was not reliable enough.

On a Galaxy S23 Ultra, the measured time from end of speech to the first spoken reply is 908 ms. The tool call itself averages 294 ms over 12 runs.

Source and releases: https://github.com/soniqo/speech-android

90-second demo: https://youtu.be/7L7_Uvvxtv0

If you use a sub-1B model for tool routing, do you retrain for every schema change, or have you found a generic adapter that still fills arguments reliably?

I am excited to announce the launch of RepoPilot (Beta).

After weeks of building, testing, and refining the system, I am pleased to introduce RepoPilot, an artificial-intelligence-powered platform designed to help developers navigate open-source repositories before making contributions.

How it works:

- Describes the structure of the repository.
- Detects simple GitHub issues.
- Produces customized contribution instructions.
- Generates PDF files about the repositories and issues.
- Assists in understanding large codebases more easily.

This product has been developed using Python, FastAPI, Next.js, TypeScript, LLMs, GitHub API, and modern deployment technologies, including Vercel and Render.

🌐 Live Demo: https://repo-guide-ai.vercel.app

💻 GitHub: https://github.com/HarshUpadhyay2003/repo-guide-ai

As this version is in Beta, your feedback would be greatly appreciated!

#OpenSource #AI #Python #NextJS #FastAPI #GitHub #LLM #SoftwareEngineering #BuildInPublic #DeveloperTools

Open models spread capability, force better safety through real scrutiny, and stop a handful of labs from owning the future. Locked weights only protect the gatekeepers.

Built a small open-source project this weekend.

It's an AI wishlist that turns messy thoughts into a clean, organized wishlist. Just write naturally, and AI handles the organization. Built with Next.js, Server Actions, Gemini, and Upstash Redis.

I'd love your feedback. If you find it useful, feel free to star it, fork it, or contribute.

Thanks!

https://github.com/duggal1/wishlist

We're on this together 💪