Every Sunday, I scan the open source landscape for projects that are gaining real traction — not just stars, but actual community engagement. This week’s haul spans AI agent infrastructure for teams, local LLM inference that breaks memory barriers, a tool that kills AI slop writing, a TUI for juggling multiple coding agents, and a Go SDK for building AI-powered backends. Let’s dig in.
1. QM — Multiplayer Agent Harness for Teams
QM rethinks how AI agents serve an entire organization. Instead of a single assistant shared across a company, each employee gets their own isolated workspace with scoped memory, files, keychain, permissions, crons, and a durable sandbox. People work independently, but they can also collaborate with the agent in Slack channels and shared projects.
The architecture is clean: a headless core handles identity, policy, and scheduling, while a Postgres layer persists sessions and memory. The agent loop is pluggable — Claude Code, OpenAI Codex, OpenCode, and Pi all drive the same core, so you’re not locked into one vendor. Each turn runs through the central API, and the agent’s execute tool runs commands in the scope’s own isolated sandbox where installed tools persist across sessions.
Beyond chat, QM supports shared skills (scope-owned, shareable by grant, with admin-gated org-wide promotion), web apps that can be spun up and published to specific people, and background work via crons and watches. The Slack integration means the same identity and configuration carries between the chat platform and the web app — no separate setup. At over 4,700 stars in its first week, it’s clearly filling a gap for startups that need multi-user agent infrastructure without the complexity of building it from scratch.
2. TurboFieldfare — Running a 26B Model in 2 GB of RAM
TurboFieldfare does something that sounds impossible: it runs Google’s Gemma 4 26B-A4B model (26 billion total parameters, ~3.88 billion active per token) in about 2 GB of RAM on any Apple Silicon Mac — even 8 GB base models. The trick is expert streaming: instead of loading the entire 14.3 GB model into memory, TurboFieldfare keeps only the shared 1.35 GB core and KV cache resident, then streams individual MoE experts from SSD as each token requires them.
This isn’t a wrapper around MLX or llama.cpp. It’s a custom Swift + Metal runtime, written specifically for the Gemma 4 architecture using Metal 4 and Swift 6.2. The project ships with a native Mac app, a CLI, and an experimental OpenAI-compatible local server. The results speak for themselves: 5–6 tok/s on an 8 GB M2 MacBook Air, and 31–35 tok/s on a 24 GB M5 Pro. The model uses MLX affine 4-bit quantization with 64-element groups for experts and an 8-bit router.
The repo includes something rare — a detailed experiment inventory documenting 103 measured results across kernels, caching, I/O, prefill, and decode optimization. The system design docs explain the caching strategy — a segmented ring buffer that tracks which expert pages are hot and evicts cold ones deterministically. For anyone working on local inference under tight memory constraints, this is a masterclass in what’s possible when you control the entire stack.
3. SimpleEnglish — Making LLMs Write Like Aerospace Manuals
AI-generated text has a recognizable register: hedging, filler, corporate politeness, and vague qualifiers. SimpleEnglish attacks this problem with a clever idea borrowed from aviation: ASD-STE100 Simplified Technical English, the controlled language aerospace has used since 1983 so a tired mechanic cannot misread a maintenance instruction.
The project is an Agent Skill — a standards-compliant SKILL.md file that works in every harness supporting the open Agent Skills standard: Claude Code, Cursor, VS Code Copilot, OpenAI Codex, Gemini CLI, Goose, OpenCode, and dozens more. No dependencies, no API keys, just a folder you drop into your agent’s skill directory. The skill enforces STE100 rules: short sentences, one instruction per sentence, approved vocabulary only, no passive voice for procedures, and no ambiguous terms.
The results are measured, not vibes. Across six Claude models, the skill reduced STE violations by 72.9% in benchmarked evals. The before/after examples are striking — verbose, apologetic error messages become precise, actionable instructions. “We have identified an issue that may have impacted some users’ ability to access the service” becomes “Between 14:02 and 14:31 UTC, 12% of login requests failed.” If your team writes technical documentation with AI assistance, this skill is worth installing today.
4. Agent-Manager — A TUI for Running Multiple Coding Agents
If you’re juggling Claude Code, Codex, Gemini CLI, Grok, and OpenCode sessions simultaneously, you know the pain of terminal sprawl. Agent-Manager is a terminal UI built in Go with Bubbletea that orchestrates all of them inside tmux sessions. You get a live status dashboard, a group tree for organizing related work, quick prompts for firing off instructions, and a diff review pane for inspecting what each agent actually changed.
The tool is deliberately minimal — it manages tmux sessions rather than reimplementing them. Each agent runs in its own tmux pane, and Agent-Manager reads the pane state to show you which sessions are active, idle, or waiting on input. The group tree lets you cluster related agents (e.g., one group for the backend service, another for the frontend). Quick prompts let you broadcast a message to multiple agents at once — useful when you want all of them to follow the same coding convention or look at the same error.
Built in Go with the Bubbletea framework, Agent-Manager runs on macOS, Linux, and Windows (via WSL2). It supports custom configuration for each agent type and integrates with tmux’s existing scripting capabilities. It’s a practical tool for a growing workflow pattern — running multiple AI coding agents in parallel on different parts of a codebase.
5. Grafana AI SDK — Streaming AI Backends from Go
Grafana AI SDK brings Vercel’s AI SDK design to Go backends. It provides a single API for model calls, streaming, tool execution, structured output, and multi-step agent loops — all wire-compatible with the @ai-sdk/react TypeScript frontend hooks. A Go endpoint can stream responses directly to a React frontend using the AI SDK’s streaming protocol, with no glue code in between.
The SDK abstracts away provider differences: you call the same interface whether you’re hitting OpenAI, Anthropic, or a local model. Tool calling is first-class — you define tools as Go functions, and the SDK handles the function-calling loop, including multi-turn conversations where the model requests tool results mid-stream. For teams already building observability tooling in Go (Grafana’s home turf), this is a natural fit for adding AI-powered features like log analysis, alert triage, or query assistance without bolting on a Node.js service.
The provider abstraction means you can swap models without touching application code — useful for cost optimization (route simple queries to a smaller model) or redundancy (fail over to a backup provider). The streaming protocol matches Vercel’s exactly, so any existing AI SDK React component works unchanged. For Go shops that have been waiting for a mature, opinionated AI SDK rather than stitching together raw HTTP clients, this fills the gap.
Wrapping Up
This week’s projects share a theme: they take something that was hard or required multiple tools and make it feel native. QM makes multi-user AI feel like Slack. TurboFieldfare makes a 26B model feel like it belongs on an 8 GB laptop. SimpleEnglish makes AI writing feel like it came from a human engineer. Agent-Manager makes five coding agents feel like one workflow. And Grafana AI SDK makes AI-powered backends feel like any other Go service. If you’re building in any of these spaces, the repos above are worth a star and a closer look.