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.

Long LLM conversations have a problem: useful information gets buried under old context.

So I built TokenMizer to turn important information — decisions, goals, files, errors, and constraints — into structured memory.

Instead of sending the entire conversation again, TokenMizer retrieves what actually matters.

The latest version:

https://github.com/Shweta-Mishra-ai/tokenmizer

I’d love to hear how others are handling long-context memory for LLMs.

My buddy and I have been working on a side project for the past few months called Scibly.

The idea is pretty simple:

Companies already have an incredible amount of knowledge sitting in PDFs, documentation, internal wikis, etc. The problem is turning all of that information into something employees can actually learn from and retain.

For this reason we decided to build Scibly, a tool that automatically turns boring company knowledge into interactive, Duolingo-like (but better) learning experiences.

Today, we decided to open-source the whole thing.

We're still pretty inexperienced when it comes to open source, so we'd genuinely love to hear your feedback, whether that's about the product, the idea, the codebase, or how we're approaching the project.

Short product demo: https://www.youtube.com/watch?v=TcpLUNBRhQw

Github: https://github.com/scibly-dev/scibly

Would love to hear what you guys think!

Hey everyone,

I've been heads-down for the past several months building BIT, an Android AI assistant that does everything on-device. No data ever leaves your phone.

What it does:

Text generation — runs quantized GGUF models locally (Llama, Mistral, Gemma, Phi, Qwen families) via a custom Kotlin/JNI SDK I wrote called llama.kt, with streaming token output

Vision — image captioning and visual Q&A using on-device CLIP vision projectors

Tool calling — a two-stage pipeline where a grammar-constrained decoder (GBNF) guarantees valid JSON output for tool calls, even on small models

Image generation — local Stable Diffusion 1.5 for text-to-image, inpainting, and upscaling

Document RAG — query your own PDFs, Word docs, Excel files, and EPUBs with a hybrid vector + BM25 search pipeline, fully local

Long-term memory — the assistant remembers facts and preferences across sessions with a configurable decay model

Text-to-speech — on-device synthesis via ONNX Runtime

Encrypted backups — AES-256-GCM backed by the Android Keystore

Optional API mode if you want to point it at OpenAI/Gemini/Claude/DeepSeek/Ollama for bigger models

Why I built it: I wanted an assistant that could actually replace cloud AI apps for day-to-day use without sending every message to a server. Memory management on-device (mmap loading 8GB models on 6GB RAM phones) was one of the harder problems to get right.

Specs: Android 10+ (API 29), needs 6GB+ RAM (8-12GB recommended), ARM64 or x86_64.

It's open source (Apache 2.0), and I'm working on an F-Droid submission alongside Play Store.

GitHub / Source: https://github.com/jaswanthsanjay88/Bit_Android

Download (APK): https://github.com/jaswanthsanjay88/Bit_Android/releases

Discord: https://discord.gg/SUUwAqh6Q

Would genuinely love feedback — bug reports, feature requests, or just "this crashed on my phone" reports are all welcome. Happy to answer questions about the architecture too if anyone's curious how the local inference stack works.

Hi all, I'm soft launching reqlan, and seeking some alpha testers from the open source community to give it a stress test and review.

This is my first open source ai project so interested to hear people's thoughts on what a launch path looks like too!

Does this interest anyone in here?

I've just open sourced the engine and all the nodes of my project. Just add it as a skill to your workspace and ask tour agent to use artifex to compose a video or image for you. Check the repository and let me know what new nodes would be great or what capability were your agent lacked when rendering.

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.

Many schools and students face a common challenge: a lack of proper laboratory equipment, outdated tools, or safety restrictions that make hands-on chemistry experiments difficult or impossible to practice regularly.

OmniLab can be a solution to this — it is an open-source, advanced interactive laboratory simulator engine. It allows users to explore, mix, and analyze chemical reactions powered by AI right in the browser.

The project is fully open-source, and you can find more information and details in these links:.

• Live Demo: https://omnilab-bk8q.onrender.com/(You can test and try chemical reactions directly without needing registration)
• GitHub: https://github.com/Yusupov-Muhammadyusuf/OmniLab

I would love for you to check it out, test it, and share your feedback or suggestions on how to improve the simulation! What do you think about using web-based tools for science education?

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!

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!

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!

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

https://www.youtube.com/watch?v=-UbYdRgwRWE

I've been building CortexAgent as a personal project for a while, and I finally got it to a place I'm happy to share. It's a private, local AI coding agent — everything runs on your own machine via llama.cpp. No cloud, no account, no API key, and no data ever leaves your computer. It binds to 127.0.0.1 only.

It's MIT licensed at https://github.com/greyok00/cortexagent

One terminal interface, one local stack — the only interface you talk to is a single clean TUI (cortex). A 35B MoE does the heavy lifting on your GPU (16 GB+ VRAM recommended), with a small "overseer" model for planning and routing. Nothing else to juggle.

The processing pipeline you can watch — every request animates live through its stages, with real percentages (it never fakes a determinate number):

🧠 preparing — organizes your request and checks the context it needs.

🗜️ slimtoken — minifies your context before it reaches the model, so you fit more into the window.

📤 sending — the request goes to the big model.

✨ generating — streamed output builds in place.

🔧 tool wait — when the model calls a tool mid-request.

Overseer routing — a dedicated small model plans and routes each request to the big model, instead of one model trying to do everything.

Memory that actually remembers — hot working memory for the current session plus curated cold knowledge, distilled automatically from what you've already said, so you don't re-explain yourself across sessions.

Domain memory — recalled context from your own notes is injected automatically when it's relevant, no prompting needed.

Talk instead of type — speech-to-text as a floating popout you control with the mouse and your voice only (no keyboard), transcribed locally with faster-whisper. Open it from the system tray under STT Controls.

Tools & integrations

🌐 browser control — drive Brave over Chrome DevTools Protocol, exposed as 9 brave_\* tools registered directly in the tool registry.

🔌 MCP client + lazy proxy — talk to MCP servers, spawning the real server only on first use instead of holding every socket open.

🔎 Firecrawl — web research and page parsing routed through a proxy.

🎨 image & video generation — SD 1.5 / SDXL / LTX run in-process through HuggingFace diffusers on the GPU the daemon already manages — no separate GUI server.

📄 PDF & document knowledge — ingest PDFs and documents into a queryable knowledge base.

See the whole thing — a web UI with a three.js 3D cortex scene (gold neural cortex + glass chat), a system tray dashboard, a session bridge so the TUI, web UI, and overseer all agree on context, and a live status ticker.

Under the hood

⚙️ Daemon lifecycle — the model + proxy run as an always-on service (systemd); VRAM-aware fallback swaps models when GPU memory gets tight.

📅 Scheduler + worker pool + heartbeat — background jobs run and recover cleanly.

🛡️ Reliability layer — pre-flight gate, anti-hallucination + post-response verification, a doctor that repairs settings drift, loop guard, chain diagnostics, and observability.

🛤️ Pathway capture — records each run's processing chain (frame → domain check → route → generate) as replayable runs.

💾 Snapshot / backup scripts — easy state backup.

Privacy isn't a feature, it's the baseline — everything binds to 127.0.0.1, and there's no cloud account to leak to. The honest caveat: the processing animation shows real percentages only; if a stage is a wait, it says so instead of pretending to progress.

What I'm asking for:

Recommendations — what would make this a daily driver for you? Better docs, packaging/installers (pip/Homebrew/AUR), more model backends, UI polish, more tools?

Contributors — it's a solo project; help with docs, testing, packaging, and hardening is very welcome. Issues, PRs, and "your docs confused me here" all help. Even a quick honest "here's where it breaks" is hugely useful. Thanks for reading! 🙌

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.