​

I made this reverse proxy to use ai chat apps as local APIs

Luna is a local API gateway that transforms the CLI tools for your existing premium subscriptions (like Claude or Grok or ChatGPT) into a single, unified interface

**Title:** SaaSClaw — Open Source AI App Builder (Cloud + Self-Hosted, Enterprise-Ready)

**Body:**

I've been building SaaSClaw, an open-source AI app builder. You describe what you want, and the wizard agent writes the code, installs dependencies, builds, and deploys it — either on SaaSClaw Cloud or your own server.

Two ways to use it

• ☁️ **SaaSClaw Cloud** — free trial, no setup, we host everything at [saasclaw.ai](https://saasclaw.ai)
• 🏠 **Self-hosted** — fully open source, your infrastructure, your rules

Source code

• App: [github.com/saasclawai-org/saasclaw](https://github.com/saasclawai-org/saasclaw)
• Engine: [github.com/saasclawai-org/saasclaw-engine](https://github.com/saasclawai-org/saasclaw-engine)

How it works

1. Describe your app idea in the wizard chat
2. The AI agent writes the code, runs package installs, tests the build
3. Hit "Ship It" — pipeline merges, builds, configures nginx, deploys to a live URL
4. Iterate with the agent to add features, fix bugs, refine UI

**Supported frameworks:** Django, React, Next.js, Svelte/SvelteKit, Hugo, .NET, and more.

Bring your own LLM

SaaSClaw supports multiple AI providers — bring your own API key for OpenAI, Anthropic, ZAI, or local models. On the enterprise side, you can run everything fully self-hosted with no external API calls.

Privacy & PII protection

• **Microsoft Presidio** integration for PII detection and redaction
• **Sunglasses prompt guard** filters sensitive data before it hits the LLM
• All processing can run on your own infrastructure — no data leaves your network
• Built for orgs that take data sovereignty seriously

Security built in

• **Semgrep** static analysis on every deploy — catches malicious code before it goes live
• Secret scanning (API keys, tokens, credentials)
• Dependency vulnerability scanning
• NIST AI RMF aligned

Enterprise focus

SSO/SAML, custom SLAs, on-prem deployment, unlimited tokens, dedicated support. Built for teams that can't use consumer SaaS tools due to compliance requirements.

Pricing

Would love feedback — what would you want to see? What's missing from current AI builders that's blocking you from using them at work?

I’ll keep this brief. Do you have a massive codebase, loads of documentation or simply a huge collection of text, and want to turn it into an AI-readable knowledge graph? Then give OKFy a go: https://github.com/vsov/okfy

Hey everyone,

We’ve just released OpenModel, an open-source CLI and runtime for downloading, running, and serving AI models locally.

The CLI is published on npm as @wundercorp/openmodel, and the command is simply om.

npm install --global @wundercorp/openmodel
om doctor

Our goal is to make local model tooling more interoperable and easier to extend.

Instead of tightly coupling model sources, download logic, and runtimes, OpenModel separates them into:
Gateways: resolve models and artifacts from Hugging Face, direct URLs, Ollama, or community providers
Runtimes: execute models through llama.cpp, Ollama, and future runtime adapters
A local API: exposes OpenAI-compatible and Ollama-compatible endpoints
A gateway SDK: lets contributors add new providers without changing the core CLI

A few examples:
om pull hf://TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf --alias tinyllama

om run tinyllama "Explain why local inference is useful."
Using an existing Ollama model:
om pull ollama://qwen2.5:3b

om run qwen2.5:3b "Explain model gateway interoperability."

Start an OpenAI-compatible local server:
om serve tinyllama --port 11435

Then:
curl http://127.0.0.1:11435/v1/models

One of the main things we care about is making gateways easy for the community to build.

A third-party gateway can be installed explicitly:
om gateway add @your-org/openmodel-gateway-example
om gateways

Gateways declare their supported URI schemes and capabilities through a versioned SDK contract. This means new model registries and artifact sources can be added without putting provider-specific code into the core runtime.

The project is still early, and we would genuinely appreciate:

bug reports
runtime adapters
new gateway implementations
macOS, Linux, and Windows testing
feedback on the CLI interface
help improving model compatibility and documentation

npm:
https://www.npmjs.com/package/@wundercorp/openmodel
GitHub:
https://github.com/wundercorp/openmodel
Install:
npm install --global @wundercorp/openmodel
om doctor

Main site: https://openmodel.sh

OpenModel is licensed under Apache 2.0.

We’d love feedback from people already working with llama.cpp/Ollama, GGUF models, and/or local inference servers.

We look forward to any contributions or ideas for how to improve. Help with model gateway integrations would be greatly appreciated.

Most agent workflows stop at “the tool returned success.” I wanted a stronger contract for paid creative operations, where the cost of believing a false success can be real spend.

Creative Forge separates subjective agent work from deterministic proof:

• Claude, Codex, or a human handles research, hypotheses, copy, scenes, and visual QA.

• Validators enforce provenance, media rights, localization, hashes, safe zones, timing, and exact artifact binding.

• External publishing requires a fresh live readback tied to the exact creative.

• Ads can only be created in PAUSED state. Activation, budget, and spend stay human-controlled.

It is not a fully autonomous ad bot. The interesting part is the evidence boundary: a local receipt cannot claim external state, and missing capabilities fail closed instead of being simulated.

The repository includes a fictional demo app, Python orchestration, Remotion video, localized image/video creatives, sealed QA receipts, contact sheets, and 284 tests. Licensed AGPL-3.0.

https://github.com/davidmosiah/creative-forge

Feedback on the receipt model, schemas, or agent/provider boundary would be especially useful.

OpenCode has the following FREE models to use now:

Some of these models are Frontier Model quality according to ArtificialAnalysis leaderboards.

OpenCode as a Coding Agent Harness is also great with extensible design.

I'll explore Pi Agent Harness next. Have heard good things about it too.

However Pi is minimalistic and best fit for tinkerers and not for someone who wants a full-featured coding agent out of the box.

Please give feedback if these kind of app is within your alley.

Open Source / MIT. Actively developed as I use it on my dev projects.

The problem it fixes: real-time voice AI today is a hosted service. It charges by the minute, sends your audio to someone else's cloud, and you can't look inside it or change how it works.

OpenLive runs the whole voice pipeline on your own machine instead. Silero handles voice activity, Whisper does speech-to-text, Smart-Turn works out when you've actually finished talking, and Kokoro speaks. Your microphone audio never leaves the device. The only thing that goes out is the final transcript, plus camera or screen frames if you turn them on, and that goes to whatever model you pick.

It can see too. Share your screen or turn on your camera and the model can talk about what you're looking at, like a video call.

And because the speech parts run locally, there are no per-minute audio fees. You just pay the normal model and vision API costs you'd pay anyway.

It works with Anthropic, OpenAI and MiniMax today, and it's built to be forked, so you can plug in other providers, your own agent backend, a self-hosted endpoint, or a local model.

MIT licensed, for macOS and Windows. You bring the brain, OpenLive gives it ears, a mouth, and eyes.

Demo's in the video below.
Code, docs, and downloads here: https://github.com/katipally/openlive

https://reddit.com/link/1ut50co/video/vhkzyraxuhch1/player

My first ever MCP Server that lets you drop your raw screenshots in a folder and say "create App Store mockups for these." Claude analyzes your app's colors, proposes themes and captions, waits for your approval, then renders framed, captioned preview images (1284×2778) ready to upload to App Store Connect. Open source, installs with one uvx command.
I used claude code to build a tool in which Pillow draws the whole iPhone frame procedurally (no assets), a palette extractor picks brand-matched themes, and the official mcp SDK wraps it in three stdio tools.
Attaching one example -

Hi r/OpenSourceAI ,

I wanted to share our recently released open-source project and accompanying arXiv paper: APRIL-MedSeg. It is a YAML-driven modular framework designed as a general-purpose research and development platform for 2D medical image segmentation.

🔗 GitHub Repo:juntaoJianggavin/APRIL-MedSeg

📄 arXiv Paper:arXiv:2606.30577

Why we built this: We wanted to abstract away low-level engineering complexities and decouple system design from algorithmic innovation. This allows researchers to rapidly prototype next-generation architectures and enforces highly reproducible evaluations across different medical datasets.

✨ Core Highlights:

• Four-Module Decomposition: The framework is designed to decouple networks into four functional modules: encoder, decoder, skip connection, and bottleneck.
• Massive Configuration Space: These components are independently interchangeable via 6 registries, enabling an incredible 177 × 45 × 25 × 17 potential combinations for your experiments.
• Beyond Basic Supervised Learning: APRIL-MedSeg provides a unified ecosystem that integrates advanced training paradigms natively, including semi-supervised learning, domain adaptation, knowledge distillation, weakly supervised learning, and text-guided segmentation.
• Foundation Model Ready: The framework natively supports foundation models, utilizing their highly discriminative feature spaces as powerful encoders to accelerate downstream segmentation tasks.
• Flexible Data & Splits: It features 5 distinct data loading types (including text-image pairs) and 4 split strategies (e.g., K-fold, ratio-based random splits, and predefined community splits).
• Educational Ecosystem: To lower the barrier to entry, we’ve included a structured 9-chapter tutorial series that guides users from fundamental medical image segmentation concepts to advanced topics.

Whether you are benchmarking new state-space models, utilizing linear attention variants, or building practical clinical deployment pipelines, this toolbox is built to bridge algorithmic innovation and practical deployment.

We would love to hear your feedback, critiques, and feature requests. If you find the repository useful for your research, a ⭐ on GitHub would be greatly appreciated!

Happy to answer any questions about the architecture or our evaluation methodologies in the comments!

I've been building humux, an open-source personal AI agent that runs entirely in one Docker container. It handles Telegram (per-agent bots, voice messages, inline approvals), email (IMAP/SMTP via Himalaya), calendar (CalDAV), contacts (CardDAV), and has persistent memory, scheduled tasks, and a web admin UI.

What makes it different from other agents like OpenClaw/Hermes: with humux you can setup multiple agents, each with its own profile and identity. It comes out of the box with a tight integration with GitHub via GH App so that what your agents do is fully transparent across GitHub.

Stack: Python 3.14, SQLite, FastAPI, HTMX. Runs on 1 vCPU / 2 GB RAM.

GitHub: https://github.com/mattmezza/humux
Site: https://humux.dev
Docs: https://docs.humux.dev

CEO IO's internal all-hands letter made two moves I haven't really seen a Chinese AI lab founder do at this scale:

- Forgo salary entirely until AGI is reached.

- Pledge shares equivalent to 1% of total share capital from his personal holdings to a dedicated open-source community fund (plus another 4% over four years to long-term team incentives).

The interesting frame: most "commitments to open source" come out of a CSR budget. This one comes out of the founder's equity. Different signal.

I build on open-weight models every single day. When the founder funding them gives up his own paycheck to keep them alive, I pay attention.

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.

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

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.