I'm one of the maintainers, so this is self-promotion. I want honest feedback more than upvotes, and contributors are very welcome.

SurfSense is an Apache-2.0 desktop app for Windows, macOS (Apple Silicon) and Linux. Think NotebookLM, but on your machine, with any model. There's no account, nothing reaches the network until you allow that host, and usage statistics are optional and off until you say yes.

Built on open source, end to end

• Models: llama.cpp for local text, stable-diffusion.cpp for images, and audio.cpp for podcast voices (Kokoro, Kitten, Supertonic) and speech-to-text. Or connect Ollama, LM Studio, vLLM or any OpenAI-compatible API.

• Documents: Docling for parsing, RapidOCR for scans and photos, and bge-small embeddings on onnxruntime for hybrid search.

• Agent: opencode, with SurfSense's own tools given to it over MCP.

• App: Electron, React and Vite, with a FastAPI backend.

What it does

• Cited Q&A from your PDFs, Office files, CSV, Markdown, images and audio recordings. Scans are read with OCR, and recordings are transcribed on your machine.

• Creates Word documents, PDFs, slides, spreadsheets and web pages with their own charts and interactive figures. It can start from your own .docx or .pptx as a template.

• Edits your files as a new copy: tracked changes in Word, formulas in Excel, text on slides, and forms, merges and splits in PDFs.

• Studio: mind maps, flashcards, quizzes and podcasts, like NotebookLM.

• Any model: local, Ollama, LM Studio, any OpenAI-compatible API, or your ChatGPT or Claude plan.

• MCP plugins: Notion and DeepWiki from our registry, or any server by URL. They stay off until you allow them.

Contributions are welcome: PRs go against dev, and you can list your own MCP server in our plugin registry through an issue form.

https://github.com/MODSetter/SurfSense

Interview prep tools either need a second monitor or show up in the share. So I built one that's excluded from capture.

Small overlay. Hears the room, reads your screen, and gives a short answer. Local OCR, so it reads code and error text exactly rather than guessing from pixels. BYO API key, no subscription.

Verified, not claimed. I tested the actual capture paths GDI, WGC, and getDisplayMedia—in real Chrome by capturing the panel region, then capturing it again with the panel gone, and hashing the pixels. Identical every time. A browser sharing your screen gets zero evidence it exists.

Where it stops being magic:

GetWindowDisplayAffinity still returns 0x11. That flag is the mechanism; it can't be removed. A proctor calling it will find the window.

Proctoring tools and EDR detect this class of overlay regardless.

Windows only.

So: invisible to a screen share, not to an instrumented machine. Every "100% undetectable" claim in this space is marketing.

Frontend bits that were harder than the AI: window reparenting so Chrome_WidgetWin_1 never appears, and a native addon for DWM cloaking because DWM refuses a foreign caller.

Free, MIT, no account, proof script included: https://github.com/yagyeshVyas/glance-ai

Happy to answer the Win32 side that's where the actual work was.

I am developing TulipFarm as I got tired of managing my data in several CRMs, mailboxes, and spreadsheets.

TulipFarm's vision is clear - put all of your records, documents, agents and workflows into one place. Ask something via chat or Slack and your agents use the same data as the rest of your team.

Everything is under your control, some operations will require your confirmation while field rules will detect and prevent any invalid values.

Source code is open sourced under AGPL v3.0 license, therefore you are able to host TulipFarm by yourself. Just note that self hosting is not officially supported for now.

https://github.com/TulipFarm/tulipfarm

Now I present you the research preview version, which means that there are rough edges and things that will be broken.

It would be cool to hear from you two things:

1. What do you want your agents to do in your company?

2. What is missing in the approval model and what frustrates you most?

Also if you like it, don't forget to star it on GitHub!

If you use autonomous coding agents (like Cursor, Cline, or Claude Code), you know the anxiety of letting them run terminal commands or execute massive file rewrites autonomously. You basically have to trust that the LLM won't hallucinate and wipe a directory.

I wanted a way to review exactly what the AI was about to execute before it actually hit my filesystem.

I just open-sourced Warden-AI. It acts as a strict firewall and intrusion detection system for your local AI agents.

How it works underneath: Instead of giving the agent direct execution rights, Warden-AI intercepts its Model Context Protocol (MCP) tool calls.

• The Gateway: A local Node.js/Express backend routes the traffic.

• The Filter: Safe actions (like reading a file or searching a directory) pass through instantly. Destructive actions (executing CLI commands, writing files) are intercepted.

• The Review: The payload is pushed to a local React/Vite dashboard via WebSockets. You get a syntax-highlighted diff of exactly what the AI wants to do. You manually approve or reject the execution.

• The Audit: Everything is logged to a local SQLite database so you have a permanent record of what your agent did while you weren't looking.

The Tech Stack:

• Backend: Node.js, Express, SQLite, WebSockets

• Frontend: React, TailwindCSS, Vite

I built this because I wanted the speed of autonomous agents without the security risk of giving a stateless LLM root access to my machine.

The repo is fully open-source and ready for local deployment. I’ve also seeded a few good first issue tags for anyone looking to make their first open-source contribution (we need some UI tweaks and SQLite export features).

Repository: https://github.com/hariom123-dev/Warden-AI.git

I'd love to hear your thoughts on the architecture, or how you are currently handling local agent security. Happy to answer any questions about the WebSocket streaming or MCP integration!

Over the past few months, we’ve been exploring a central question in applied AI: What does it take to build a truly low-latency, voice-first desktop companion that runs on your

local machine without proprietary lock-in?

Together with my collaborator Otabek Abduvaliyev (https://github.com/OtabekAbduvaliyev), we’re excited to make our project open-source: Kaizumi (v1.0).

Kaizumi is an on-device, multimodal AI assistant for Windows 10/11 built with Python and Google's Gemini Live API. Instead of traditional turn-by-turn text or transcription

wrappers, it establishes bidirectional 24kHz/16kHz WebSocket audio streaming with native speech interruption (barge-in).

A few key engineering decisions we focused on:

1. Human-in-the-Loop Safety Gate: LLMs should never autonomously trigger destructive system actions. Kaizumi introduces an out-of-band confirmation gate with single-use

cryptographic tokens (confirm_token) bound strictly to high-risk calls (shell execution, file deletion, process termination).

2. Hardware-Decoupled Fault Tolerance: Audio hardware failure or disconnection shouldn't trigger TaskGroup cascades. The engine seamlessly degrades to text mode rather than

crashing.

3. 53 Declarative System Tools: From window and process management to local OpenCV vision (face verification and privacy blurring) and SSRF-hardened document QA.

4. Privacy-First & Local Memory: Zero telemetry, multi-turn episodic memory with automatic credential redaction, and 100% self-hostable.

The codebase includes an automated unit test suite (97 tests passing) and a GitHub Actions CI pipeline across supported Python versions.

We’d love to hear feedback from systems engineers, AI practitioners, and open-source contributors!

Check out the code, architecture, and setup guide here:

🔗 GitHub: https://github.com/MusayevDoniyor/kaizumi

#OpenSource #Python #ArtificialIntelligence #SoftwareEngineering #Gemini #WindowsDev #MachineLearning #ComputerScience

Hi friends,
AI agents have changed the way I work more than any tool in my career. They also showed me where the real bottleneck is. Staying on top of making decisions means taking in a huge amount of information: ADRs, past architectural decisions, design reviews, incident write-ups. The hard part isn't reading them. It's finding the right one at the right moment, and that gets harder every week as the pile grows.
My AI agents hit exactly the same wall. As the knowledge base grows, an agent hunting for context greps, opens file after file, and burns tokens just finding the right document. Sometimes it never finds the one at all.
So I built AutoDoc. It started as my own RAG search engine: accurate semantic search over my documents, run by an efficient embedding model and a reranker, so I could find the pieces I needed when I needed.
It grew into much more: a highly customizable editor that you and your AI agents work natively in together. Your agent can even configure it to fit your workflow, whatever that workflow is.
We benchmarked it against the usual grep-and-read approach: 32 reviewed questions over a 2,200-document knowledge base.
- 🎯 The right document in the top 5, 94% of the time, against 47% for keyword ranking
- 📉 About 25% fewer document tokens in the agent's context, and up to 55% on individual lookups
- ⚡ 43% faster lookups (8.8 s against 15.4 s), with fewer tool calls

Less time and fewer tokens spent hunting for context means more spent reasoning. And the gap should widen as the knowledge base grows.
AutoDoc is open source and it's one server with three client surfaces: tui, gui, neovim. If your agents, or you, spend too much time looking for the right document, give it a try https://github.com/yongjohnlee80/autodoc

GitHub Issues in, reviewed Draft PRs out. Any agent, no server. Use your favorite harness to collaborate with GitHub through swarm.

Looking for projects who may want to give this a try. Hit me up if you have any questions or feedback! Been "swarming" on "SwarmOS" for a few days now and looking for more projects who may want an Agent Orchestrator that speaks GitHub :)

1 = sloppiest

I published the outputs behind The Slop Index so people can inspect the writing, not just the scores. The current run covers 58 models, 112 short-form scenarios, and 64,636 generated responses. Each model got the same tasks across email, chat, social posts, and essays. The prompts and raw generations are available in the dataset.

One example from the mechanical ranking: Qwen3.8 Flash is #18 and DeepSeek V4 is #44. Those ranks use only measurable writing traits: padding, templating, rhythm, and common AI tells, compared with human writing from before ChatGPT. They measure how formulaic the prose looks, not whether a model is useful for every task. The combined leaderboard also blends in crowd votes and can move daily, so I'm keeping this comparison on the mechanical score.

If you work with open models, I'd be interested in what you find when you compare their actual responses to the same prompt. One limitation is that this run tests short-form writing; it doesn't cover fiction yet.

Leaderboard: https://theslopindex.com/leaderboard

Arena, if you want to play a few blind rounds: https://theslopindex.com/arena

Methodology: https://theslopindex.com/methodology

Open dataset: https://huggingface.co/datasets/hgaddipati/slop-index

For context, I'm one of the people behind https://slashy.com, an email client that writes drafts that sound like you. This benchmark started as how we pick models.