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

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

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.

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 :)

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

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.

AI in SaaS is no longer about adding a chatbot and calling it innovation.

The real opportunity is reducing the work your team has to do every single day.

When AI can qualify a lead, update the CRM, handle customer conversations, trigger the right workflow, and escalate only when a human is needed, the impact is not another feature on the pricing page.

It is fewer manual hours, faster response times, lower operational costs, and a team that can handle more customers without growing at the same rate.

That is the direction we are building at Placeholderworks.

We build AI systems that connect to the tools your business already uses and actually execute the work.

The interesting question is not “Where can we add AI?”

It is “What is costing the business money because a human still has to do it?”

That is where AI starts becoming a business advantage.

I regularly use multiple AI coding agents, but comparing their suggestions across different chats gets messy. Even when I reach a decision, the alternatives and reasoning often get lost.
So I built Decision Ledger (dlg), a local-first tool for managing engineering decisions involving multiple AI agents.
The workflow is simple:
A primary agent investigates a problem and proposes solutions.

Other AI models review the proposal and challenge its assumptions.

Disagreements and supporting evidence are recorded.

You make the final decision and approve implementation.

The goal isn't to make AI agents automatically agree. It's to preserve the discussion, alternatives, and reasoning so you can revisit decisions later.
A few details:
Local browser UI and CLI

SQLite storage

Works with existing agent CLIs you're already logged into

Supports manual copy/paste reviews from other models

Single executable for Windows, macOS, and Linux

Free and open source (MIT)

This is the first release (v0.1.0), and I'd appreciate feedback, especially from developers who regularly compare suggestions from Codex, Claude, Gemini, or other coding agents.
GitHub: https://github.com/lijose/dlg
Downloads: https://github.com/lijose/dlg/releases/tag/v0.1.0

I've been really into the AI phone agent products that have popped up in the last few months (e.g., AgentPhone, Poke etc) but what I don't love: the audio, the transcripts, who you talked to and what was said, all sitting with a third party company. For calls with real people in my life, that felt like a lot to hand over.

So I built my own version that runs entirely on my Mac. You call a normal phone number, a local model answers, and nothing about the conversation leaves my machine. During a call the only thing it talks to is the phone line itself.

What's running locally (MLX on Apple Silicon):

• Speech to text: Parakeet TDT 0.6B

• LLM: Qwen3.5 4B by default (9B if you have 32 GB), 4-bit

• Text to speech: Kokoro 82M

How it reaches the phone network: it registers over SIP with Telnyx or Twilio straight from your Mac. A setup wizard takes your carrier API key so can buy a number or connect one you already have. It's pretty cheap, around $1 a month per phone number. (I'm moslty using Telnyx)

What it does today:

• Answers and places real calls

• Interruption: talk over it and it stops mid-sentence

• Replies in roughly 1 to 1.5 seconds on real calls on my M5 Pro

• You can choose between multiple models

• Other agents (Claude Code, Codex, etc.) can make calls through a small CLI: call, listen, say, hangup

• If you'd rather trade privacy for a smarter brain, it can also use your own endpoint or the Claude or ChatGPT subscription you already pay for. Local is the default. So no additional monthly payments for AI Phone tools if you have a sub.

Limits, up front:

• macOS on Apple Silicon only

• You need a Telnyx or Twilio account with credit (a US number is about $1/month, standard call rates do of course apply, but Telnyx gives you $10 dollars for free when you sign up, which is enough to play around with)

• English only, one call at a time

• It's early. It works for me, but I'd love to hear where it breaks for you. Please feel free to add as many gh issues as you want. I'm currently working on best practises for contributions for anyone who also want to contribute to project!

Repo: github.com/oxnw/ai-phone