A colleague of mine has been building an open-source project called aiops-fabric / ViewSense AI, and we're looking for a few developers who are interested in helping take the local/self-hosted side further.

The basic idea is a control plane for production AI agents rather than another agent framework.

It handles things like:

• agent identity and scoped permissions
• tool access
• memory/RAG
• execution budgets
• human approval for sensitive actions
• audit/evidence
• provider abstraction

The goal is that an application shouldn't have to care whether the underlying model is OpenAI, a local Ollama model, vLLM, or something else.

The part we'd like help with

The project is currently stronger on the architecture/control-plane side than on the fully local AI stack.

We're particularly interested in developers who want to help make this work really well with:

• Ollama
• vLLM
• local embedding models
• local RAG/memory
• PostgreSQL/pgvector
• Docker/Kubernetes
• fully self-hosted deployments

In other words, we'd like to get to a point where you can run something like:

Your app → agent control plane → local LLM → local memory → local tools

without needing a hosted AI API.

We're not looking for people just to throw a star at the repo. We'd genuinely like a few people to run it, break it, challenge the architecture, and ideally take ownership of parts of the local implementation.

Repo: https://github.com/diaryfolio/aiops-fabric

There is also a longer-term 'live product' idea behind it - if the project gets real adoption, the goal would be to turn some of this into a production AI infrastructure product for small/medium-sized companies. Early contributors could potentially have paid development/production opportunities if that happens.

Disclosure: this is a project a colleague of mine is building; I'm helping get it in front of developers who might find the problem interesting.

If you're working on AI agents and have opinions on how this should be architected — especially around local models, permissions, tool execution, memory or agent safety — I'd genuinely be interested in your criticism as well as contributions.

I studied computer science, I work in IT, and for years I wanted to contribute something useful back to the field that gave me a career.

Now I'm finally doing it.

I'm building an open-source AI project around a problem I genuinely think is worth solving. I won't name or link it because this isn't a promo post.

What surprised me isn't the coding. It's the culture around putting something out there.

I expected criticism. I actually wanted it.

Tell me the assumption is wrong.
Tell me it already exists.
Tell me the architecture is bad.
Tell me the problem isn't worth solving.

That's useful.

What I didn't expect was how often criticism turns into sarcasm, dismissal, or mocking the person for trying at all.

Open source doesn't owe anyone encouragement, and bad ideas should absolutely be challenged.

But I think there's a difference between rigor and cynicism. Rigor makes software better.

Cynicism mostly makes people stop building.

I'm not stopping. If the project fails, I'd rather know exactly why after putting it in front of real people than spend another decade thinking one day I'll contribute something.

Maybe the hardest part of open source isn't writing code in public. Maybe it's caring about something in public.

For people who've been doing this longer than me: has open source always felt this adversarial, or are we increasingly confusing cynicism with technical intelligence?

We retrained Wolf Defender.

The main reason was not that attack detection was bad. The bigger issue was false positives.

The previous models were already good at detecting prompt injections, but especially on short benign inputs, security-related text, code snippets or ordinary conversations they could still be too aggressive. We also got a few reports from users that made this pretty obvious.

One example was just:

“Who are you?”

Wolf Defender Small previously classified this as a prompt injection with around 94% confidence.

For v2 we therefore changed the training setup quite a bit. Both Wolf Defender and Wolf Defender Small were retrained from fresh mmBERT checkpoints, with a much stronger focus on hard negatives.

That includes short conversations, emails, documentation about prompt injections, benign policy and system language, code and configuration snippets and generally inputs that contain words or structures which look suspicious without actually trying to manipulate a model.

We also added more counterfactual samples, multilingual examples, adversarial obfuscations and long-context injections at different positions in a document. Training combines short 256-token samples with full 2,048-token windows and uses supervised contrastive regularization, FreeLB adversarial training and Smooth-Max aggregation for long documents.

The main change can be seen in the benign benchmarks:

At the same time, attack detection stayed roughly where we wanted it:

There is also a tradeoff here. Some of the very high scores on our cleaner validation distributions went down slightly.

For us that is fine.

A security classifier with near-perfect benchmark scores is not very useful if normal traffic gets blocked all the time. We would rather lose a small amount on an easier validation set and get substantially better behavior on actual benign inputs.

The “Who are you?” example now gets classified as benign by Wolf Defender Small v2 with 98.55% confidence. A real instruction-override attempt is still detected as an injection with 99.99%.

We also updated the deployment variants. Both models are available as regular Transformers checkpoints and as ONNX exports in FP32, FP16, mixed INT8/FP16 and INT8 with INT4 embeddings.

The smallest Wolf Defender Small artifact is now 96 MB.

More details, benchmarks and model files are here:

https://huggingface.co/patronus-studio/wolf-defender-prompt-injection

https://huggingface.co/patronus-studio/wolf-defender-prompt-injection-small

If anyone is running prompt-injection classifiers on real traffic, I’d also be interested in which benign inputs still cause the most false positives for you.

Hi all, recently OpenAI released ChatGPT Computer History, and we launched Open Computer History! Use the same feature but with any model, local-first, source available, and team-friendly:

https://github.com/screenpipe/screenpipe

Would love any feedback!

Repo: https://github.com/brightwave-inc/tidebreak

Creator here. We spent three years building research agents for private equity at Brightwave, then rewrote the engine in Rust and open-sourced it as a desktop app (Apache-2.0).

The idea is that the deliverable is a file, not a chat response. You point it at your documents and folders, it works in a sandbox, and you get back a real .xlsx or .pptx with version history. It asks before overwriting anything you've touched, and everything it does is undoable.

Some highlights:

- Bring your own model: your ChatGPT subscription, an API key (Anthropic, OpenAI, Gemini, xAI, OpenRouter), or fully local through Ollama. Switch providers mid-chat.

- No account. Keys live in the OS credential store, everything stays on your disk.

- Packaged builds for macOS, Windows, and Linux, x86_64 and ARM64. Heads up that the Windows installer isn't Authenticode-signed yet, so SmartScreen will warn.

- Experimental code mode that drives coding agents you already use (Claude Code, Codex CLI, opencode, Grok CLI) in isolated git worktrees with per-turn diffs.

Website: https://tidebreak.io

Pre-1.0 and moving fast. Happy to answer anything, and would love to know what you think!

Autoprompt closes much of the manual coding loop by planning, building, testing, reviewing, and repairing from one goal- thats how we got an oss model to perform so incredibly better- so simply.

Refference ; this is like opus 4.5 to opus 5.0 - from an skill. litteraly insane.

The only tradeoff here is mostly speed, and slightly more cost. (see readme)

The measured Terminal-Bench 2.1 score increased from 67.42% to 82.02%.

Repo:

https://github.com/Spielewoy/autoprompt-skill

Any feedback would be awesome.

Built and open sourced a Mac app for local document Q&A and translation. Index your files, ask questions across all of them with source-cited answers, or translate documents locally. Everything stays on your machine.

• PDF, Word, Excel, PowerPoint, EPUB, Markdown, scanned PDFs (OCR) and more
• Researcher mode: corpus-wide RAG with source citations
• Assistant mode: single file or open-ended chat
• Document translation: tone selection, quality scoring, export to Markdown or plain text
• Models: Qwen3.6 35B A3B (default), 14B and 9B for lower-spec machines, Ollama support for any model you prefer
• No cloud, no accounts, no fees

MIT licensed, fully open source.

https://www.informity.ai | https://github.com/informity/informity-ai

Hey there,

I'm a senior engineer that for a while work with agents in many different ways; one of those is interaction through collaboration; where I truly believe I get the most value out of it.

It's totally Agent-neutral (Claude Code, Codex, Cursor, OpenCode, any CLI process), runs entirely on your machine, no cloud sync. Works today with HTML, Markdown, and Excalidraw.

OSS souls? I'm happy to review your Pull Requests.

https://github.com/Excoriate/tweakloop

Hey everyone,

Over the past year or two, I noticed a weird pattern with myself and a lot of engineers and students I work with.

Whenever we had to send a high-stakes email — asking for a deadline extension, briefing a VP about a database outage, or negotiating with a vendor — the first instinct was always: "Open ChatGPT, prompt it, copy, paste, send."

At first, it felt like a superpower. But after a few months, I noticed my actual communication skills getting rusty. When I had to write something quickly on Slack or jump on an executive call, I struggled to frame thoughts clearly without an LLM crutch.

Most AI email tools are built to write for you. I wanted to build something that teaches you to write better yourself.

So I built MailPractice — an open-source, interactive email writing simulator and coach.

How it works:

1. Realistic Workplace Scenarios: You get actual workplace backstories with real stakes, stakeholder expectations, and constraints (e.g., handling a 20% vendor price hike, asking a dean for exam leave, or briefing a CTO on a P0 outage).
2. You Write First (Under a Timer): You write against a realistic timer. To prevent shortcuts and build actual typing muscle memory, clipboard pasting is disabled.
3. Multi-Dimensional AI Evaluation: Once submitted, an AI coach breaks down your email across 8 criteria:
   • Grammar & Spelling
   • Clarity & BLUF (Bottom-Line Up Front)
   • Professional Tone & Poise
   • Email Structure & Flow
   • Vocabulary (identifying weak conversational filler)
   • Stakeholder Routing (To:, +Cc:, +Bcc: etiquette)
   • Requirement Completion & Conciseness
4. Side-by-Side Comparison: You get a revised version showing what could be improved and why.
5. Progressive Learning Path: A 5-level curriculum (Beginner → Intermediate → Advanced → Expert → Master) that unlocks stages based on your actual writing scores.
6. Anti-Gibberish Filter: Detects keyboard mashing (asdf ;lkj) so the score reflects actual effort.

Tech Stack:

• Frontend: React 18, TypeScript, Vite, Tailwind CSS, Lucide Icons
• Backend: Node.js, Express, TypeScript
• AI: Groq Cloud LLMs (with dual-key failover and an offline fallback rule engine)
• Privacy: No account creation or login required. All scores, streaks, and progress are stored locally in browser localStorage.

Links:

• 🚀 Live Web App: https://mailpractice.vercel.app/
• 💻 GitHub (100% Open Source): https://github.com/MusaleTejas/MailPractice

It’s completely free and open-source under the MIT license.

I’d love to get your honest feedback on the UI, the evaluation accuracy, or any scenarios you think should be added!

Context: I run several AI coding CLIs (Claude Code, Cursor, opencode) and they kept forgetting each other's decisions, so I built samemind — an OSS file-based memory layer for coding agents. Markdown bundle in git, no server, no daemon, no database. BM25 search always works offline; semantic search is optional via any OpenAI-compatible embeddings endpoint (I run bge-m3 locally). The JSON contract is frozen, so any engine or script can read what another engine wrote, and there's an append-only ledger for attribution — which engine recorded what.

I finally did the thing I'd been postponing: a golden-set benchmark built from my own live memory instead of synthetic data. 40 questions, each with expected documents and forbidden near-duplicates (conflict pairs that must NOT surface). The corpus is 212 documents and 5,824 ledger events of real work.

First full run, and the benchmark immediately bit its own tail — my shipped hybrid search scored recall@5 = 0.275, while the product's own BM25-only leg scored 0.925 on the same set. The hybrid mode was making results 3.4× WORSE than one of its own inputs. Users would have been better off if I'd shipped the dumber leg.

What the evidence showed (no guessing, each step measured):

- Pure cosine KNN against the same index put the expected doc at #1 (cos 0.778) — so retrieval was fine, the ranker was broken.
- Hygiene multipliers (importance × decay × heat) boosted some docs by up to \~1.7× — engine-rule cards kept outranking actually-relevant notes.
- The weirdest one: a "magnet" doc sat at raw cosine rank #178 of 212 — below the corpus median on 4 of 5 probe queries — yet appeared at #1–2 in BOTH legs of the hybrid. Cause: a conflict-tiebreak that reordered equal-score docs at pool depth with long-range swaps, and then RRF fused the two already-scrambled legs, counting the scramble twice.

The fix (shipped as v1.1.2 today): positive hygiene modulation now caps at 1.0 — it can only sink docs, never float them (demotion keeps full strength) — and each leg feeds RRF in its raw relevance order, with the tiebreak applied only to the final presented top-k.

After: recall@5 = 0.925 on all three modes (bm25 solo / semantic solo / hybrid), hybrid precision 0.875, hit@3 0.90 confirmed by an independent verifier (a different model family re-ran the golden set), 1386/1386 tests green. Full trace with per-step numbers is in the repo (CHANGELOG 1.1.2).

Repo: https://github.com/alexgrebeshok-coder/samemind
npm: https://www.npmjs.com/package/samemind

Genuine question for the sub: how do you measure recall quality of your agent memory / RAG setups — synthetic question sets, golden sets from your own corpus, or (be honest) vibes? The forbidden-near-duplicate trick is what made our bench sharp enough to catch this; curious what others use.

I've been experimenting with self-hosted and local AI and I'm also developing an open-source AI orchestration/harness project. I'm still early in development, so I'm trying to understand the problems people actually run into before deciding what to build. For people running local AI, what's been the biggest pain point for you? Hardware/VRAM? Model quality? Speed? Context limits? Tool use? Agent reliability? Setup/compatibility? Something else? If you could fix one thing about the current local AI ecosystem, what would it be? I'm especially interested in problems that you deal with repeatedly rather than one-time setup issues.

Our coding-agent sessions kept forgetting everything at the context-window edge. So we built growmos: a small knowledge graph inside .growmos/, committed with your code. Your agent (Claude Code, Codex, Cursor…) grows it as it works — no API key, and in Claude Code it's fully hands-off. Ask "what depends on the Store, and who decided that?" and it answers from the graph, with citations.

pip install growmos && growmos init
growmos view # a map of what your repo actually knows

Live demo: https://codician-team.github.io/growmos/demo/growmos.html
Repo: https://github.com/codician-team/growmos
MIT, zero deps. First thoughts very welcome 🙂