r/LovingOpenSourceAI

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:

Model	Benchmark	v1	v2
Wolf Defender	Hard benign specificity	81.57%	96.23%
Wolf Defender	Real-world benign specificity	66.85%	96.63%
Wolf Defender Small	Hard benign specificity	82.12%	96.67%
Wolf Defender Small	Real-world benign specificity	73.60%	94.38%

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

Model	Qualifire F1	Jayavibhav F1
Wolf Defender	95.14%	97.84%
Wolf Defender Small	95.21%	97.68%

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.

https://github.com/crewAIInc/crewAI

Community Overview: https://lifehubber.com/ai/resources/crewai/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/krea_ai/status/2089766521912561688

Hey everyone!

Over the past year, as I tried to scale our agentic coding workflows and software factories at my company, I kept hitting the same set of problems. So I built HAR to solve them.

Repo: github.com/os-factory/har

Getting a single coding agent to work in a repo is easy. Scaling to a real multi-agent workflow, where several run at once and where you verify and trust the output, is where it breaks down. A few things go wrong:

1. No standard way to run or verify a repo. That knowledge is scattered across a README, a CLAUDE.md, editor rules, and CI config, all drifting out of sync with each other and the actual code.
2. Agents on one repo collide. Shared dev server, shared database, shared ports, conflicting git state.
3. Trusting a change means re-verifying it yourself. Which defeats the point of running a fleet.
4. Vendor sandboxes lock you in. If the setup lives in someone's hosted dashboard, switching agents later means rebuilding the whole thing.

What HAR does

HAR is a CLI and an MCP server. It works with Claude Code, Cursor, Codex, or any MCP agent, and it closes each of those gaps:

1. Isolation. Each agent gets its own git worktree, branch, ports, and database. Nothing is shared with the main checkout or another agent's slot, so a fleet runs in parallel without colliding on a dev server, DB, or ports.
2. Deterministic validation gates. HAR runs your project's real checks through a fixed pipeline, same result every time. The result is bound to the exact code that passed and enforced at commit time, so an unverified tree cannot land.
3. Verifiable proof. Every run leaves logs, artifacts, and a validated tree hash tied to the exact code checked. A reviewer inspects the evidence instead of trusting the agent's self-report.
4. Full observability. Mission Control is a local dashboard showing every repo, worktree, run, and validation in one place, so you can watch a whole fleet as it works.

All of this lives in one contract committed to your repo, which every agent reads the same way. It replaces the usual scatter of a README, a CLAUDE.md, editor rules, and CI config that drift apart. You start from a profile that matches your stack, your agent adapts it to the real repo, and you extend verification with plugins (like Playwright) or with any command you already run.

Give it a try and let me know what you think :)

https://x.com/tinyhumansai/status/2070584474560241701

https://github.com/tinyhumansai/OpenHuman

Community Overview: https://lifehubber.com/ai/resources/openhuman/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/oliviscusAI/status/2088841514801889666

https://github.com/opendataloader-project/opendataloader-pdf

Community Overview: https://lifehubber.com/ai/resources/opendataloader-pdf/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/cohere/status/2087571573947392419

https://huggingface.co/CohereLabs/North-Micro-Vision-Instruct

Community Overview: https://lifehubber.com/ai/resources/north-micro-vision-instruct/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

Here’s the cleaned-up list (no individual project links):

1. Flax: Neural network library for JAX designed for flexibility.

2. Needle: 45M-parameter foundation model and 14MB inference engine for tool calling and structured extraction on tiny devices.

3. Switchyard: Rust proxy and library for routing and protocol translation across LLM backends and coding agents.

4. OpenProgram: Self-programming agent framework for executable workflows with models, tools, memory, and multi-agent execution.

5. Ouroboros: Self-hosted general-purpose agent with durable identity, memory, specialist subagents, and reviewed self-changes.

6. Open Multi-Agent: TypeScript orchestration framework for runtime multi-agent task DAGs, approvals, tracing, evaluation, checkpoints, and resumable execution.

7. Obsidian Agent Skills: Agent skills and open-format tooling for Obsidian vaults and compatible AI coding agents.

8. Hexis: Git-backed platform for sharing skills, tools, and context across AI agents through a remote MCP server.

9. LoopTroop: Local-first AI coding workspace orchestrating multi-model planning councils, Git worktrees, and task loops.

10. firstmate: Agent distro for running autonomous coding agents in isolated Git worktrees.

11. Agent Skills (Anthropic): Official Agent Skills and reference implementations for Claude Code, Claude API, and AI agents.

12. VidXP: Local-first multimodal video indexing and semantic search with transcripts, embeddings, and scene-aware search.

13. Code-Graph-RAG: Multi-language codebase RAG framework using Tree-sitter and Memgraph knowledge graphs.

14. Zoom Search: MCP search and evidence tool with query rewriting, source zoom-in, sourced answers, and runtime metrics.

15. invisible-playwright: Stealth-patched Firefox Playwright wrapper for AI agents ingesting sites with anti-bot guardrails.

16. Modly: Desktop application for image-to-3D mesh generation using local GPU-accelerated AI models.

17. flameox: Runtime-evidence toolkit coordinating profiler captures and comparing GPU-kernel and inference runs.

18. WeatherNext: Global weather and tropical cyclone forecasting framework from Google DeepMind, including WeatherNext 2, GraphCast, and GenCast.

19. Harvey LAB: Benchmark dataset and execution harness for evaluating AI agents on complex legal work across 24+ practice areas.

20. LifeOS: Personal AI harness and assistant framework with persistent memory, custom skills, and goal tracking.

21. Macro: Unified team workspace combining email, messaging, documents, tasks, CRM, and AI agents with shared memory.

22. Forge: Open-source terminal AI coding agent with a Rust TUI, editor, shell, SQLite journals, MCP, and approval-aware execution.

23. CLI-Anything: Framework for converting software applications into agent-native command-line interfaces.

24. oai-smoke: Standard-library-only Go CLI validating OpenAI-compatible API model and chat behavior without credentials or response bodies.

25. Entroly: Local-first MCP server for budgeted context selection, exact recovery, and auditable Context Receipts.

26. AMD Strix Halo Local LLM Guide: Reproducible Ubuntu, Ollama, llama.cpp, Vulkan/RADV, and ROCm setup and benchmark evidence for Ryzen AI MAX+ 395 local AI systems.

Awesome Open Source AI full list https://awesomeosai.com

https://x.com/sudoingX/status/2088551892901327198

Claude is now #3 on our community ballot with an approval rate of 47.3%. Too low? Too high? Or just about right? Vote: https://lifehubber.com/ai/ballot/

Found this today and thought it was worth sharing.

Someone built an open-source Unreal Engine plugin that integrates TRELLIS 2 directly into the editor, so you can basically go from an image to a generated 3D asset without constantly jumping between different tools.

It supports:

• image → 3D generation with TRELLIS 2
• local or remote generation
• 1K / 2K / 4K settings
• background removal
• seed and generation controls
• generation progress directly inside UE
• automatic download and import of the generated GLB into the scene

The local mode is probably the most interesting part to me. If you already have TRELLIS 2 running locally, this starts looking less like a separate AI toy and more like an actual part of the Unreal workflow.

Still pretty early, but integrations like this are exactly where I think 3D AI becomes genuinely useful.

GitHub: https://github.com/camenduru/TostEngine-trellis2-unrealengine-plugin

https://huggingface.co/LiquidAI/LFM2.5-VL-3B

Community Overview: https://lifehubber.com/ai/resources/lfm2-5-vl-3b/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

I think we all went through this. Claude finished a task, told me it was done, and left me with 14 changed files and no idea which one mattered. The diff was accurate and useless. So I built the thing I wanted to be looking at instead.

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Agent smells. Rules for shortcuts agents take and humans usually don't: a test edited in the same burst as the code it covers, assertions deleted, .skip added, type suppressions introduced, coverage thresholds lowered.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Runs in a browser too. Same bundle, same backend, over a websocket, because the backend has to run on the machine the agent runs on and that's often not your laptop. One port, token auth, works behind Codespaces / Gitpod / a JupyterHub proxy.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

https://x.com/huang_chao4969/status/2088812504642097237

https://github.com/HKUDS/CLI-Anything

Community Overview: https://lifehubber.com/ai/resources/cli-anything/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/deepseek_ai/status/2087887408440164663

https://github.com/deepseek-ai/deepseek-harness

Community Overview: https://lifehubber.com/ai/resources/deepseek-harness/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

https://x.com/Alibaba_Qwen/status/2088280182356611304

https://huggingface.co/Qwen/Qwen3.8-27B

Community Overview: https://lifehubber.com/ai/resources/qwen3-8-27b/

Resources are shared for discovery and are not independently vetted—please do your own due diligence.

New resources are added regularly — feel free to join the sub for updates.

Full searchable archive of all resources posted so far on our community site, LifeHubber: https://lifehubber.com/ai/resources/ 200+ open-ish AI models, agents, tools, datasets, and related resources, with filtering and sorting.

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.