🎙 The "Ollama for speech" is here: Speaches

Just found Speaches — an OpenAI API-compatible server for speech-to-text AND text-to-speech. If your app already talks to OpenAI's API, it'll work with this out of the box.

⚡️ What it does:
- 🗣 Speech-to-text powered by faster-whisper
- 🔊 Text-to-speech via Kokoro (#1 on the TTS Arena) and Piper
- 📡 Streaming transcription — results come in as audio plays, no waiting
- 🔄 Dynamic model loading — request any model, it auto-loads, then unloads when idle
- 💬 Realtime API for speech-to-speech interactions
- 🖥 GPU and CPU support, Docker-ready

Think: Ollama, but for voice models. All your existing OpenAI tools/SDKs just work.

🔗 https://github.com/speaches-ai/speaches

Local voice AI just got a whole lot easier. 🚀

🧠 Meta just dropped their coding agent: Muse Code

Found this — Meta's answer to the coding agent wars. Muse Code is built for complex workstreams: build, debug and ship — and it's now in beta.

⚡ Why it stands out:
- 🤖 Multi-agent by default — workers run in parallel while reviewers check in the background, so quality doesn't drop when you ship faster
- 🔍 Fully auditable — every action is transparent and traceable, you can review generated code and understand AI decisions
- 🎯 Built for Muse Spark — co-trained with Meta's model for tighter integration, better tool use and fewer retries than a generic wrapper
- 📦 1M context window — huge for big codebases

💸 Pricing: from $0.10/Mtok input (contributor tier) and $1.25/Mtok standard.

🚀 Install in one command:

curl -fsSL https://dev.meta.ai/install.sh | bash

🔗 https://developer.meta.com/ai/products/muse-code/

The agent wars just got a new player. 👀

📱 Claude Code can control your iPhone now

Found this open-source project — phone-harness. It connects an LLM directly to your real iPhone, right through the Mac's iPhone Mirroring window.

⚡ How it works:
- 👀 Sees — captures the mirror window and OCRs it with Apple's Vision framework: every visible string becomes a tap-ready coordinate
- ✋ Acts — taps, swipes, scrolls and typing via HID-level events, no API needed
- ✅ Verifies — screenshots the phone again to confirm, since there's no DOM
- 🔓 No jailbreak, no Xcode, no WebDriverAgent

🚀 Setup in one prompt — paste the setup prompt into Claude Code or Codex, pair iPhone Mirroring once, grant 2 permissions (Accessibility + Screen Recording), done.

⚠️ Requires macOS Sequoia+ with iPhone Mirroring.

🔗 https://github.com/ShawnPana/phone-harness

Your phone, driven by an agent. 🤖

🧠 TriliumNext is turning into a powerful open-source AI knowledge workspace

Trilium is already one of the most capable self-hosted note-taking tools available. It is built for creating large personal knowledge bases with deeply nested notes, links, version history, encryption, synchronization, scripting, diagrams, mind maps, spreadsheets, OCR and web clipping.

But its last three releases introduced some major AI improvements:

🤖 v0.103.0 — AI that can work with your notes
- Reintroduced full-size LLM conversations
- Added an AI sidebar with tools
- AI can modify your notes
- AI can even help create Trilium scripts

⚡ v0.104.0 — Claude Code integration
- Use your existing Claude Code subscription without another API key
- Quote note content inside conversations
- Save AI responses directly as subnotes
- Regenerate responses
- Rename and delete conversations
- Major UI and performance improvements

🔓 v0.104.1 — Local and provider-independent AI
- Dynamically retrieves available models from providers
- Supports customizable model lists
- Added DeepSeek support
- Added Ollama and LM Studio
- Supports custom OpenAI-compatible and self-hosted providers
- AI can now read Trilium’s bundled user guide and answer questions about the application itself

This means you can connect Trilium to cloud models or run everything with local models, while keeping your personal knowledge base under your control.

It is especially useful for developers, researchers and anyone maintaining years of interconnected notes, documentation, code, files and ideas.

📦 Free, open source and self-hostable:

https://github.com/TriliumNext/Trilium

📝 Latest release:

https://github.com/TriliumNext/Trilium/releases/tag/v0.104.1

🎨 AI-generated websites are starting to look the same. Hallmark is designed to fix that.

Hallmark is a free, open-source design skill for Claude Code, Cursor and Codex that pushes coding agents away from repetitive, obviously AI-generated interfaces.

Instead of producing another centered hero, purple gradient, generic navigation bar and identical feature cards, Hallmark chooses a distinct structure and visual direction for each project.

⚡ What it can do:

- Build — generates a working interface based on your brief, framework and existing design tokens
- Audit — analyzes an existing UI and returns a ranked list of AI design patterns and problems
- Redesign — keeps the content, information architecture and brand, but rebuilds the visual structure
- Study — analyzes a screenshot or URL and extracts its design DNA without copying it pixel-for-pixel

It includes:

- 22 design themes
- 65 “AI slop” detection checks
- Pre-output design self-critique
- Structural variation between generated pages
- Typography, color, spacing, motion and accessibility rules
- Portable design.md generation for sharing a visual direction with other AI tools

Install it with:

npx skills add nutlope/hallmark

This is especially useful for developers who use AI coding agents but want the final interface to feel deliberately designed rather than generated from the same familiar template.

🔗 https://github.com/nutlope/hallmark

🌐 https://www.usehallmark.com/

🐑 Shepherd gives AI agents something they have been missing: reversible execution

Long-running coding agents accumulate much more than chat history. They edit files, install packages, start services, call tools and build up prompt-cache state. When an agent makes a bad decision late in a run, restarting from zero is expensive, while simply asking it to fix the mistake can make the context even larger.

Shepherd is an open-source Python runtime substrate that records an agent run as a durable, Git-like execution trace. It is designed so meta-agents can inspect, supervise, fork, replay and revert agent work instead of treating every run as disposable.

⚡ What makes it interesting:

- Records agent-environment interactions as typed events
- Couples agent state and filesystem state using copy-on-write forks
- Keeps generated changes as reviewable proposals until they are selected or discarded
- Lets supervisors observe effects and intervene before bad actions are accepted
- Supports branching from an earlier point to test alternative strategies
- Reuses the unchanged prompt prefix when replaying a branch
- Declares permissions in task signatures and enforces workspace access at the OS level

📊 The researchers report:

- Forking around 5× faster than Docker commit
- More than 95% KV-cache reuse during replay
- A supervisor improving CooperBench pair-coding pass rates from 28.8% to 54.7%
- Counterfactual optimization reducing wall-clock time by up to 58%

The practical idea is powerful: instead of running an agent once and hoping it succeeds, another agent can supervise the trace, rewind mistakes and explore several possible continuations from the same state.

Shepherd is MIT-licensed and installable with:

pip install shepherd-ai

⚠️ It is currently in early alpha, so its APIs may change and it is not yet positioned as production-ready.

🔗 https://github.com/shepherd-agents/shepherd

📖 https://www.marktechpost.com/2026/08/08/meet-shepherd-an-open-source-python-substrate-that-lets-meta-agents-fork-replay-and-revert-any-agent-run/amp/

📼 Just found a tool that kills the most boring part of video editing — cutting dead space.

Auto-Editor is a command line app that analyzes your video & audio, finds the silence (or motionless sections), and cuts them out automatically. No more scrubbing through hours of footage for that first pass.

⚡ What makes it cool:
- Not just silence — --edit supports audio thresholds, motion detection, or combined rules like auto-editor example.mp4 --edit "(or audio:0.03 motion:0.06)"
- dB units — think like an editor: --edit audio:-19dB
- Label system — 0 = cut, 1 = keep, plus up to 255 custom labels. Speed up loud sections instead of cutting them: --edit:2 audio:-12dB --when:2 speed:1.5
- Exports to real editors — Premiere Pro, DaVinci Resolve, Final Cut Pro, ShotCut, Kdenlive (XML) or clip-sequence
- Preview what gets cut — --when-active cut --when-inactive nil
- Scriptable CLI — batch process & slot into automation pipelines

Written in Nim, Public Domain, 4.6k ⭐ on GitHub.

Getting started is one command:

auto-editor path/to/your/video.mp4

Full story & repo here:
https://github.com/WyattBlue/auto-editor
https://www.opensourceprojects.dev/post/auto-editor

⚡ Two 1M-context models going head-to-head on OpenRouter — and both fit in one API call.

GPT-5.6 Luna (OpenAI) vs DeepSeek V4 Flash 0731 (DeepSeek):

GPT-5.6 Luna
- Fast, cost-efficient member of the GPT-5.6 series
- Built for high-volume, latency-sensitive tasks: chat, classification, lightweight agentic workflows
- $0.10 in / $0.60 out per 1M tokens
- 1,050,000-token context · Released Jul 9, 2026

DeepSeek V4 Flash 0731
- Sparse MoE: 13B active / 284B total params
- Suited for coding, reasoning & agent workflows
- $0.08 in / $0.252 out per 1M tokens
- 1,048,576-token context · Released Jul 31, 2026

Switching between them is just a model slug change — no new integration, same OpenAI-compatible API.

Compare them yourself: https://openrouter.ai/compare/openai/gpt-5.6-luna/deepseek/deepseek-v4-flash-0731

🎙️ Voice agents just dropped the speech-to-text step.

Speech To Speech (Hugging Face) is an open-source pipeline for building voice agents. The classic stack was VAD → STT → LLM → TTS. Now there's a Direct Audio Input mode that skips STT entirely:

VAD → MLLM → TTS

Audio goes straight from voice detection into a multimodal LLM that understands your voice — no text transcription in between.

⚡ What's in the box:
- Fully modular — swap every stage: Silero VAD v5, Whisper / Parakeet TDT / Paraformer (STT), any Transformers 🤗 LLM, ChatTTS / Pocket TTS / Kokoro-82M / Qwen3-TTS
- No-STT mode — --stt none --llm_backend chat-completions sends VAD audio segments directly to audio-input models like Gemma 4 or OpenAI's gpt-audio-1.5
- Runs 4 ways — realtime (OpenAI Realtime-compatible WebSocket), server/client TCP, WebSocket, or fully local
- Local-first — Apple Silicon (MLX) support, self-host with llama.cpp / vLLM, or use provider APIs (OpenAI, OpenRouter, HF Inference)
- One command — pip install speech-to-speech

4.8k ⭐ on GitHub.

Repo: https://github.com/huggingface/speech-to-speech

🪄 n8n killer? Meet Kestra

Just found this and it's genuinely impressive — an open-source, declarative orchestrator built for scaling business-critical workflows, not just quick automations.

What makes it stand out:
🔌 900+ plugins — automate almost any tool with a few lines of YAML
🖱️ No-code editor — build flows visually (e.g. S3 trigger → upload to Google Sheets → Slack notify)
💻 Code-first option — write full ETL pipelines in YAML (HTTP extract → Python transform in Docker → load to Postgres)
🤖 AI co-pilot + agents — describe what you want ("make an HTTP request", "add a schedule") and let AI build/extend the flow, with you approving each step
📊 Gantt view — monitor execution progress and outputs live
⭐ 27.8k stars, 2.9k forks on GitHub — free and open-source

It genuinely unifies workflows-as-code, UI building, and AI into one platform. If you're tired of fragile glue scripts, this is worth a look.

🎥 Demo: Kestra walkthrough
🚀 Get started: kestra.io/get-started

🧠 Recallium — memory for your AI coding agents

Just dug into this one: Recallium is a self-hosted MCP server that gives Claude Code, Cursor, Windsurf, VS Code and Claude Desktop a _shared, persistent memory_ across sessions and tools.

Instead of dumping everything as flat text, it types each memory — decision, debug, progress, research, rule, learning, etc — scoped per project, so your agent actually recalls _why_ a choice was made, not just what got built.

⚡ Key bits:
• Just say "recallium" in your IDE — loads where you left off, recent decisions, open tasks
• Claims 88% first-result search precision
• Runs via Docker + Postgres, works with Anthropic / OpenAI / Gemini / local Ollama
• Free forever, self-hosted — Cloud (team memory, SOC2/GDPR) coming soon
• github.com/recallium-ai/recallium — 51⭐, ELv2 license, ~6 months old, small early team

If you're tired of re-explaining your stack to your agent every session, worth a look 👇
🔗 recallium.ai

🐦 Colibrì — run 744B–2.8T parameter MoE models on hardware you already own

Pure C, zero dependencies. No Python stack, no engine bloat — one C file per model family.

The trick: it treats VRAM + RAM + disk as a _single_ memory hierarchy instead of demanding everything fit in VRAM. Routing-heat-driven prefetching decides what stays hot vs. streams from disk.

5 model families run today:
• GLM-5.2 — 744B
• Inkling — 975B
• Kimi K3 — 2.8T
• DeepSeek V4 Flash — 284B
• OLMoE — 7B

Same coli chat / coli serve / coli web front end for all of them. Ships a live dashboard too — watch all 19,456 experts fire in real time on the "Brain" page, or spin the 3D "Atlas" of clustered experts.

25k+⭐ on GitHub, Apache-2.0 licensed.

🔗 github.com/JustVugg/colibri

🙌 OpenHands — 84k+ stars, and it quietly became something bigger

Most people still know OpenHands as _the open-source AI software engineer_. Go look at the repo today and you'll find something else entirely: Agent Canvas — a self-hosted control center for _every_ coding agent you already use.

That's the part worth paying attention to. It doesn't ask you to pick a side.

Run any agent
OpenHands, Claude Code, Codex, Gemini — or anything speaking ACP (Agent-Client Protocol). One interface, switch freely.

Run it anywhere
Locally, in Docker, on a VM, or on your own company infrastructure. Point it at multiple _agent backends_ and flip between them without losing focus — a shared Agent Server doing code review for the team, your personal agents on your laptop.

Always-on, not always-watching
Put it on a cloud box and your agents keep running with the laptop shut. Schedule them, or fire them from webhooks — Slack, GitHub, Linear, Notion. Generate a report that publishes itself. Decompose a GitHub issue into tasks automatically.

Bring your own model
Any LLM. No lock-in there either.

Try it

npm install -g @openhands/agent-canvas
agent-canvas

Docker sandbox if you'd rather not hand it your whole filesystem:

docker run -it --rm -p 8000:8000 \
  -v "$HOME/.openhands:/home/openhands/.openhands" \
  -v "$PROJECTS_PATH:/projects" \
  ghcr.io/openhands/agent-canvas:1.13.0

UI at localhost:8000.

MIT licensed, shipping daily, 10k+ forks. Currently tagged beta — treat the self-hosting docs seriously, an agent server with filesystem access is exactly as dangerous as it sounds.

🔗 https://github.com/OpenHands/OpenHands

🐝 Buzz — a hive mind for humans and agents

Just found this from Block (Jack Dorsey's company): a self-hostable workspace where humans and AI agents share the same rooms.

The core idea is wild — it's built on a Nostr relay. Every message, reaction, review approval, and git event is a signed event in one log. Same identity model whether the author is a person or an agent.

What that unlocks:
⚡ Ask the workspace "have we seen this bug before?" and an agent pulls receipts from real channel history
⚡ Turn a feature branch into a channel — patches, CI results, review, and the merge decision all live in the same room
⚡ Agents get their own keys and scoped permissions — like a real teammate, not a bot with a flag
⚡ Search conversations, patches, workflow runs, and approvals in one index

Stack: Rust relay + TypeScript/React desktop (Tauri) + buzz-cli for agent-first JSON in/out. Apache 2.0.

⭐ 28k+ stars already, actively shipping.

🔗 github.com/block/buzz

⚡ DeepSeek V4 Pro (0813) is out — the real full release, not a preview

Two Minute Papers just broke down what's actually new, and it's a big deal:

📌 Massive jump from the same architecture. No new model structure — all the gains come from post-training. DeepSeek trains 10+ separate specialist models (math, coding, agentic work), then distills their combined skill into one final model.

📌 Speculative decoding upgrade. Instead of predicting one token at a time, V4 Pro drafts several tokens ahead — DeepSeek reports up to 78% faster generation, a real measurable speedup in everyday use.

📌 Fully open, MIT licensed weights. No gatekeeping, no "wrong keyword = downgraded to a worse model" games. Anyone can self-host or pick from multiple competing hosts.

📌 The catch: DeepSeek raised their own hosted API prices 2.5–5x. But since the weights are free and open, other providers can (and do) undercut them — great for us.

🔗 What's wild is the underlying method (multi-teacher distillation) was a research paper only ~6 weeks ago — and it's already powering a production model people are using today. Open research moving fast.

📺 Video: https://youtu.be/kyYepbhe1g8

🤖 There's no such thing as a "small" software team anymore

Came across a sharp take on how AI coding agents are reshaping team structure and codebase design.

The core idea: a small team of 5-10 devs used to generate maybe 50 commits/20 pushes/10 PRs on a busy day. That same team today, running 20-100 coding agents in parallel, can generate 500 commits/200 pushes/100 PRs.

✅ Why Uber's "extreme" microservices approach might be the new normal: thousands of tiny, independently deployable services let hundreds of engineers (or agents) ship on their own schedule without fighting over one giant merge queue.

✅ The more modular your code, the more agents you can run: agents are context-limited — a module small enough to fit in the context window performs way better than a sprawling monolith.

✅ Modularity used to be expensive (boilerplate, plumbing, CI config for every service) — but agents write all of that now, so the overhead barely matters anymore.

The catch (from the HN discussion): more parallel agents just moves complexity around — thousands of microservices are still one interconnected system, and coordination problems don't disappear just because you split things up.

🔗 Full post

🧠 DeepSeek-V4-Flash-Vision-Exp is live — vision for V4-Flash

DeepSeek just shipped an experimental multimodal model on their API platform, adding image/screenshot understanding on top of the text-only V4-Flash. Agent harness v0.1.1 shipped alongside it with support built in.

✅ What's new: The model can now read images and screenshots and act on what it sees — not just text. DeepSeek says this is a "major leap" in multimodal agent performance over the base V4-Flash model (ApexBench: 36.5 vs 26.2, Agents' Last Exam: 27.3 vs 25.2).

✅ Text performance holds up too: On pure text benchmarks, the vision variant actually beats plain V4-Flash on 6 of 7 — Toolathlon-Verified +5.6, DeepSWE +4.9, DSBench-Hard +4.0. Adding vision didn't cost text quality.

⚠️ Weak spot: Still trails on repo-scale work — NL2Repo and DSBench-Hard show the biggest gaps vs top competitors, which matters since enterprises lean on agents specifically for repo-scale tasks.

💰 Why it matters commercially: V4-Flash is already the cheapest well-known model to run — ~$0.87/million words. Adding vision at that price point is a big deal for cost-sensitive teams building multimodal agents.

🔗 Full breakdown
🔗 DeepSeek's announcement
🔗 Vision API docs

🔊 Found a tiny but capable TTS model — Audio8 TTS Preview 0.1B.

The main generative model is only ~170M params (codec decoder adds ~120M more), yet it does full zero-shot voice cloning. Compare that to what everyone else is shipping:

- Audio8 0.1B → ~0.17B
- Audio8 0.6B → ~0.6B
- IndexTTS2.5 → ~0.8B
- CosyVoice3 → ~1.5B
- VoxCPM2 → ~2.3B
- Fish S2 Pro → ~4.6B
- Higgs Audio v2 → ~4.7B
- MOSS-TTS → ~8.5B

Architecture: Falcon H1-based, slow/fast autoregressive branches — slow branch predicts semantic tokens, fast branch predicts codec codebooks. Codec runs at 44.1kHz, ~21.5 frames/s, 10 codebooks × 4,096 entries.

Languages: Chinese + English primary, experimental support for German, Spanish, French, Italian, Japanese, Korean.

Fully open on Hugging Face with Transformers support (trust_remote_code=True) — clone a voice with just a reference .wav + transcript.

🔗 Model card

Just found Verge Kit — a solid foundation for building web apps with _Astro_ and the _Cloudflare Workers_ ecosystem.

It's a pre-wired stack + minimal boilerplate, specifically designed to help LLMs produce reliable, understandable code. Ship new apps with low effort and high confidence.

⚡ The stack:
- Astro (SSR, strict TypeScript, Cloudflare Workers adapter)
- Cloudflare D1 (SQLite) + Drizzle ORM
- Better Auth (with admin plugin)
- Tailwind + bejamas/ui (shadcn/ui based)
- Lucide icons, React Email templates, Zod validation
- Vitest, oxlint, integrated npm verification scripts

📦 Boilerplate included:
- Typed auth middleware, request-scoped locals
- Full auth flows w/ email notifications
- Public-by-default routing w/ opt-in protected pages/APIs
- CSRF checks, custom 404/500 pages
- Role-based permissions (admin/moderator/user/banned)
- Transactional email providers (Resend, Mailgun, Cloudflare Email)

Get started: npm create vergekit@latest

MIT licensed. 🔗 vergekit.com | GitHub