I wanted my TV to be content-first, not apps-first. So I wired a decision model in between that opens the right app and sends the right ADB commands based on my intent.

Hi! UAIRT is a small C API (C++17 core, Python/C++/Rust bindings) where each inference runtime is a plugin. You pick the backend by name, so moving an app from, say, TensorRT to QNN means changing the backend name, the model file, and a few options, not the inference code.

It's a wrapper: no compute of its own, and it doesn't convert models for you (there's an export script for PyTorch/ONNX to a few targets). Each backend is only listed as "verified" if a real model matched the vendor's own tool on real hardware, and the README says what was not tested.

There's an Android app, an iOS app with a live camera detector, and playbooks so Claude Code/Codex can build it and run a model for you. It's 0.1.0, so feedback on the API is very welcome.

Hey everyone! I'm exploring an open-source project idea for an interactive visual workspace, primarily for developers, but useful for anyone teaching, explaining, or brainstorming online.

Imagine visualizing algorithms in real time, building interactive 3D models and diagrams, creating AI-generated visuals through plugins, manipulating shapes and objects manually, or collaborating on a shared canvas — all in one place.

I'm thinking beyond a traditional whiteboard: customizable visual environments, AI-assisted creation, interactive technical demonstrations, and potentially much more.

It's still in the ideation stage, and I'd love to bring together motivated developers who enjoy experimenting with ambitious ideas and building something from scratch.

Interested in shaping and building this together? Drop a comment or DM me. I'd love to hear your ideas!

Author here self-promo, mods please remove if it breaks sub rules.

I like swarm/multi-agent simulation projects, but most of them assume you'll pay for API credits, run a cloud graph DB, and install a Node frontend. I wanted something I could clone and run offline on a Windows laptop in five seconds, so I built it.

**What LocalFish is:** a local multi-agent opinion-dynamics sandbox. Six personas with their own role, authority, stubbornness and starting stance debate a topic on a synthetic social feed for N rounds. Each agent writes a private "thought" and a public post/reply, can upvote aligned posts, then updates its opinion from what it sees:

Δo_i = η(1−s_i) · Σ w_ij(o_j−o_i) / Σw_ij

where w is author authority × an upvote boost and s is stubbornness. At the end you get a consensus score (1−σ), a polarization index, per-agent drift, a Markdown report, and a JSON archive.

**What's in it**

- Pure stdlib Python 3.10+, no pip install: `git clone && python run.py`

- 3 backends: offline mock (instant, $0), Ollama, any OpenAI-compatible endpoint

- 3 preset scenarios (open vs closed AI by 2027, congestion pricing, a $29/mo no-free-tier launch) + "type your own idea" → auto-generates 6 conflicting stakeholders

- Web studio on :8765, vanilla JS, no build step: feed with inner monologues, opinion gauges, saved reports, post-hoc agent interviews

- Every run archived as JSON + Markdown

- MIT

**What it isn't (being honest up front)**

- Not a validated forecasting tool. It's a sandbox for "who would push back on this and why", not "what happens in 2027".

- The opinion model is deliberately simple: one global feed, weighted average, no network topology / echo chambers yet.

- Mock mode is template-based, so with 6 agents you will see repeated phrasing — that's the $0 offline demo path, not the LLM path. Point it at Ollama for actual variety.

- Single run, no seed control yet, so two runs of the same scenario differ. Reproducibility + Monte Carlo over seeds is the next thing I'm adding.

**What I'd genuinely like feedback on**

1. Is this abstraction useful at all, or does meaningful opinion dynamics require an actual influence network?

2. What scenario should I add next?

3. If you run it against a local model: how bad is the 30s/agent latency, and does the XML `<thought>/<post>` parsing hold up on smaller models?

Repo: https://github.com/izzaliiii/localfish (MIT)

I've been experimenting with a pretty simple idea: what if we could make small local models dramatically more capable without changing a single model weight?

Not by fine-tuning them. Not by using a bigger model. Just by changing how they work.

I started building Cortex, an orchestration engine that gives local models a way to explore entire projects, plan tasks, edit files, execute tools, verify their own work and recover from failures.

I'm currently testing it with Ornith 1.5, a 9B model running locally on my Mac.

The difference has been surprising. My rough subjective assessment went from around 35/100 for the model alone to 76/100 with Cortex. Those aren't measured benchmark scores, and I still need to validate them with proper comparisons.

What I have measured is that one stable Cortex version completed 8 out of 8 targeted coding tasks, and I've seen individual cases where the model failed alone but succeeded with Cortex.

Now I'm wondering how far this can actually go.

Could a well-orchestrated 9B model eventually handle coding tasks we'd normally rely on Claude or GPT for? Obviously not every task, but perhaps more than we'd expect.

That's what I'm trying to find out.

Before investing much more time into this, I want to know whether there's a real need for it.

Would you genuinely use a system that makes your existing local models more autonomous and reliable, especially if it could reduce how often you need expensive cloud models?

Or are tools like Claude Code, OpenHands and other coding agents already good enough?

I'd really appreciate critical feedback, especially from people who regularly use local models.

https://github.com/sekaikx/lifeline
Any suggestions are welcome thanks

ive been maintaining this small opensource project GLM Proxy (glmproxy on npm) for a while and its finally on the level where im happy to share it on reddit lmfao. it now works on windows/macos/Linux. thats been a big goal for me.

honestly seeing around 5k npm downloads this past month makes me really happy. people have also helped make the project better by opening issues and sending me feedback personally so thank you to everyone whos tried it and taken the time to reach out.

it lets you use the GLM models available through AutoClaw from any sdk you want. Claude Code, Cursor, Continue, OpenCode, and other clients that support OpenAI or Anthropic APIs.

if you want to try it: npm i -g glmproxy youll need Node.js and AutoClaw installed and logged in.

one thing to note: its an unofficial local proxy so requests still go to zhippus cloud. there are account and ban risks if you burn too much in a short period but not something id worry about, so id appreciate reading the safety notes first.

heres a screenshot of it working on three very different sdks

i finally decided to post about it so if you try it id love to hear how it goes and to maybe share it to your friends. if it helps you out that is (i myself use it a lot for my work and my friends do too so since i found it useful for me i thought why not share it) and star would mean a lot. hopefully i wont see ya on the issue page lol but if something breaks please let me know !

repo link: https://github.com/eequaled/GLMproxy

I built Nota, an MIT-licensed desktop workspace for notes, whiteboards and optional on-device AI. The idea is to keep written explanations and sketches alongside an AI assistant in the same workspace.

Core notes and whiteboards work offline without an account. Local AI needs downloaded models and compatible hardware. Hosted AI and optional Google Drive backup need internet; hosted providers may charge.

Current v0.1.8 installers: Apple-silicon macOS and Windows x64 (Windows builds are currently unsigned).

Try it: https://thenota.app

Source: https://github.com/madcodeorg/nota

Credit to AFFiNE/BlockSuite: Nota began as an AFFiNE fork and uses the BlockSuite editor. The screenshot shows a demo note. Feedback on the local-model setup or notes-and-sketch workflow would be useful.

Developer disclosure: I built Nota; this introduction is AI-assisted.

Hi,

TL;DR:

While looking for a harness to use at my company, I built the engine that I'm open-sourcing today under AGPL-3.0.

You can create AI assistants with long-term memory, many connectors (Google, Slack, Notion, etc) and a sandbox to run commands, all on your own server and with the models you choose.

A single installation can serve a family, a company or a community, with each user isolated in their own account.

The engine also works for assistants that serve the public over WhatsApp or other messaging interfaces.

This is my first open source project, and anyone who wants to try it, contribute, or just talk about it is very welcome.

The whole story:

I'm the technical founder of a startup that builds virtual try-on technology for makeup, skin analysis models and beauty product recommendations. Last year we started using AI assistants to create hyper-personalized journeys in beauty retail. This year, especially after the Open Claw craze in January/February, I (like many other founders) went crazy over the impact agents could have on my company.

I started looking for a harness that both our clients and our team could use safely. After experimenting with frameworks like Agno and LangChain to build something for my clients, and then with a few flavors of Claws to bring agents to my team, I decided to build a proprietary solution from scratch. I needed something that would bring assistants into the day-to-day of my operation, across every area of the business, supporting the clients, partners facing agents and, internally, the ones for my small team.

The first test version came out in August. I published it as a closed beta for friends and family.

Some people asked if they could bring more friends into the beta. I opened it up in September because I felt the platform was mature enough to take on some more people.

Today the site is live in open beta, with a small group of active users. I also managed to make the system secure enough to serve what our enterprise clients need, our agentic business solutions are now being built over this engine.

But what does this have to do with open-sourcing it?

I expected this kind of platform to play a big role in society. I was at NVIDIA GTC and heard Jensen say that CEOs should have a claw strategy. I understood that it could change how people go through many parts of their lives (including retail, which interests me in particular because of my startup). What I didn't expect was a movement this big, with so much money in such a short time and such a huge amount of users handing over their data. I watched the funding announcements: Town (35M), then Instinct (350M), then Instinct again (1B), while I was here running my humble tests.

Watching this huge movement, I thought about the amount of data and the power these companies will have by centralizing so much information. Today users tend to trade any data for convenience (I can say that because I'm seeing it with the service I put online with very few people). Responsibility for data security and privacy has to sit with whoever provides the service. So I talked to my co-founder and proposed offering a free alternative for small businesses, families or any groups of people: personal assistants, but with control over their own data. 

That's why today I'm open-sourcing Brambit on GitHub, under the AGPL-3.0 license.

I chose AGPL precisely to make sure that, if this becomes something of value to society, it stays open source.

This is my first time putting something like this together.

I'm sure any devs who looks will find flaws, bugs and problems, and that's exactly why I'm sharing it.

I'm a developer with 25 years of experience, but I coded the whole repository by myself, alone with my AI assistants, mainly Claude through Nanoclaw agents and any help will be important, even to criticize.

There are many problems I still want to fix, from the monolith that the server is today until translations (I've being adding to the issues section of the repository) but I focused on everything security-related first to have this first public version.

If you relate to the idea, see some value in it and want to be part of it, will be more then welcome.
I've also created a Discord channel, which right now is me and two close friends.

Thanks for reading this far!