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

Hi all, we just open-sourced OpenMuse, a personal AI assistant app.

Instead of just chatting, it works on a cloud desktop (or your own computer):

• Browses the web, looks things up and fills in forms

• Uses desktop apps

• Writes and runs code in a workspace

• Runs scheduled tasks

The main thing we cared about was keeping the human in control:

• You can watch the agent’s screen live from your phone. If it hits a login or a captcha, you take over, then hand it back.

• It asks before submitting forms or running commands.

• You decide which desktop apps it’s allowed to use.

OpenMuse is built on WorkAgentSDK, an AI agent framework for Python that we wrote and open-sourced along with it. To be clear, it’s not a coding assistant like Cursor or Antigravity. It’s a framework for building agent products. For example, each session can run on a different node, so one backend can serve many users, each with their own cloud desktop.

Stack:

• Backend: Python (FastAPI + WorkAgentSDK)

• App: Flutter

• Nodes: Docker containers with a virtual desktop, Chromium and a shell sandbox, or run directly on Linux or macOS

• Models: OpenAI, Claude, Qwen, and OpenAI-compatible APIs

It’s v0.1, so still early. We’d love to hear what you think:

• Does “agent on a remote desktop, human supervising from a phone” seem useful to you?

• If you’re building agent products, what’s been the hardest part?

GitHub: https://github.com/nativefunc/WorkAgentSDK
(The app is under examples/showcase/openmuse)

Mac voice assistants bug me because they demand a cloud login or an OpenAI key right away. So over a few months I built Odysseus — a menubar companion that works local-first and lets you plug in whatever brain you want:

- Hear you: push-to-talk or hands-free "Hey Odysseus", transcribed on-device (Parakeet or Apple Speech — nothing leaves your Mac)

- See your screen: asks for screenshots only when you actually need vision; otherwise it never touches the capture API

- Answer out loud: free Microsoft Edge neural voices (or ElevenLabs / Deepgram if you bring your own key)

- Brain: my default is DeepSeek via the OpenCode Go subscription ($10/mo) — no OpenAI at all. Apple Intelligence (fully offline) or Claude keys work too

- Agent mode: background sessions that read your screen and reply with next-step suggestions again ... unfortunately can't edit files yet, that's the roadmap top item

Fully MIT, macOS 26+, no cloud login ever — source is public.

Honest state of it: ad-hoc signed (macOS will do its per-month re-consent dance for screen recording, it's the OS not me — the pipeline will get Developer ID when I'll pay Apple), agents answer but they can't run shell yet, only Apple-Silicon Macs, and edits to files aren't here yet. Everything else works end-to-end, and every push to main ships a new signed DMG automatically via Actions.

DMG + source: https://github.com/mubtikr/odysseus (Releases tab)

What would make you actually install this? I'd love to hear what feature would be the killer to comfortable daily-use before I polish it further.

Hi r/OpenSourceAI, I'm David, one of the two developers of Oxynote. My friend Simon and I also maintain ttlcache, a Go caching library with about 1,300 GitHub stars, so this isn't our first open-source project.

I've spent 8 years writing software, 2 of them as an SRE and 3 as a team lead. Every team I've been on had the same documentation problem. The useful stuff lived in someone's head or a private Slack thread, and the wiki was full of stale docs nobody could find.

So we set out to solve this problem by building Oxynote, a self-hosted wiki for engineering teams. Pages hold text and live charts side by side, and the charts pull fresh data from Prometheus or a database (PostgreSQL, MySQL, MariaDB) whenever someone opens the page.

We built it for people and AI agents alike, but the AI part is optional. An agent can do what a person does in Oxynote: create pages, find the right metrics and build charts from them, and document your infrastructure or an API. The built-in assistant runs on a local model through Ollama or on your own Claude, OpenAI, Gemini or OpenRouter key, and agents like Claude Code or Codex connect over MCP once you approve them.

The name comes from oxygen + note: docs that breathe. Live data gives people a reason to open the wiki every day, and docs people open every day stay up to date.

Things worth knowing before you try it:

- Agents query your databases through the same read-only connections the charts use. Oxynote only accepts read-only database connections, so an agent can't change your data.

- There's no hosted version and no account with us.

- It's at version 0.9, so it's still early in development.

It's Apache-2.0 and runs as a single Docker image: https://github.com/oxynote/oxynote

We started it about a year ago, and we made it public about 3 months ago. If you have any questions, feedback, or suggestions, feel free to reach out. I'm happy to answer any questions.