Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Last Thursday, September 3, Nvidia confirmed it will acquire Hugging Face for $12.93 billion - its second-largest acquisition ever, with closing expected in the first half of 2027. The price buys the home of open AI: 3 million models, 500,000 datasets and 18 million developers.

Nvidia’s motives read two ways. Defensively, its biggest customers are designing their own chips, and a thriving open-model ecosystem keeps everyone else on Nvidia silicon. Offensively, those 18 million developers provide an enormous demand signal for its infrastructure roadmap.

For OSS, the bull case is straightforward: Hugging Face gets effectively unlimited backing from a company that has funded plenty of open AI. The bear case is structural: neutrality is gone. A model hub owned by one chip vendor has incentives to favor its own stack, while competing labs may think twice about publishing there.

Microsoft bought GitHub, kept it thriving, and still integrated the platform deeply into its own AI strategy. What Nvidia does next is speculation. The change in ownership is not.

Which leaves the question for builders: do we need alternatives?

🦙 Ollama (GitHub) 180.1k ☆ - the vendor-neutral runtime for open models

The Scoop: Ollama runs open models - Kimi-K2.6, GLM-5.2, DeepSeek, gpt-oss, Qwen, Gemma and the rest - on your own hardware with a single command across macOS, Windows, Linux and Docker. Founded by Jeffrey Morgan and Michael Chiang, it has grown into one of the largest developer platforms in the open-model ecosystem: 8.9 million monthly developers and more than 67,000 community integrations, run by a team of just 14.

Why It’s a Big Deal

• It is the neutrality counterweight to the acquisition. Weights are pulled once and run offline; no hub owner sits between you and inference.

• The coding-agent wave increasingly plugs into Ollama. ollama launch claude connects local models to Claude Code, Codex, Copilot CLI, DeepSeek Harness and OpenCode.

• Investors have decided the runtime layer is a business. A $65M Series B led by Theory Ventures in July brought total funding to $88M, with usage doubling since January and nearly a million new installs per week.

Under the Hood

• A single Go binary wrapping llama.cpp as its execution backend, running quantized GGUF weights on CPU or GPU. MIT licensed.

• A local REST API on localhost:11434 plus official Python and JavaScript libraries.

• A Modelfile format and registry at ollama.com/library combine model distribution and execution without requiring an external hub.

Ollama is not just a model runner - it is the neutral ground the ecosystem just lost at the hub layer.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🕶️ Obscura (GitHub) 24.6k ☆ - a headless browser for AI agents, without Chromium

The Scoop: Obscura is a Rust headless browser for scraping and agent automation. It renders natively without Chromium, runs JavaScript via V8 and speaks the Chrome DevTools Protocol, making it compatible with existing Puppeteer and Playwright setups.

Why It’s a Big Deal

• Browsers are becoming the hands of AI agents, but those hands usually require a roughly 300MB Chromium build. Obscura packages the job into a 70MB binary using around 30MB of memory and loads pages in about 85ms.

• Cloudflare ported it to Workers as a prototype of its own agent-first browser, a strong signal that infrastructure players see value in the architecture.

• The engine remains Apache-2.0 and fully featured, while a hosted Obscura Cloud is planned for teams that do not want to operate it themselves.

Under the Hood

• Native Rust rendering with V8 for JavaScript and CDP compatibility.

• Built-in anti-detection, screenshots, live screencasting and PDF export.

• Near-instant startup compared with roughly two seconds for headless Chrome, making short-lived agent browser sessions substantially cheaper.

Obscura is not just a lighter Chrome - it is the web-access layer of the agent stack rebuilt as an independent primitive.

⚡ vLLM (GitHub) 90.9k ☆ - the serving engine where open weights become infrastructure

The Scoop: vLLM is the high-throughput inference engine that turns open weights into production APIs. Born in UC Berkeley's Sky Computing Lab, it is now maintained by more than 2,000 contributors across academia and industry and supports 200+ model architectures behind an OpenAI-compatible server.

Why It’s a Big Deal

• If Hugging Face is where open models are found, vLLM is increasingly where they are served - by enterprises, neoclouds and sovereign AI programs.

• It is hardware-agnostic by design: NVIDIA, AMD and Intel GPUs, x86/ARM/PowerPC CPUs, plus plugins for TPUs, Gaudi, Ascend and Apple Silicon.

• No single company controls it. Its governance is unusually aligned with its role as shared AI infrastructure.

Under the Hood

• PagedAttention for KV-cache management, continuous batching, chunked prefill and prefix caching.

• Broad quantization support including FP8, MXFP4, INT8/4, GPTQ/AWQ and GGUF, plus speculative decoding and disaggregated prefill/decode.

• Tensor, pipeline, data, expert and context parallelism, with OpenAI-compatible, Anthropic Messages API and gRPC endpoints. Apache-2.0.

vLLM is the execution layer where open weights become production infrastructure.

🎙️ VoiceStudio (GitHub) 16.7k ☆ - the fully local ElevenLabs alternative

The Scoop: VoiceStudio, by Palash Deb, is an open-source desktop app for local voice cloning, dubbing, transcription and audio production. It wraps 16 TTS and 11 ASR engines behind one interface, spanning 646 languages with no account, API key or usage meter.

Why It’s a Big Deal

• It shows open models escaping hosted platforms beyond chat: workflows people currently buy subscriptions for can increasingly run offline.

• Rather than betting on one model, engines can be switched per task - the same small-core, many-backends architecture appearing elsewhere in local AI.

• It can plug into agent stacks through a local REST/SSE/WebSocket API, OpenAI-compatible audio API and MCP server.

Under the Hood

• AGPL-3.0 application for macOS 13.3+ Apple Silicon, Windows x64, Linux and Docker.

• CUDA, Apple MPS/MLX, ROCm and CPU compute backends, plus optional remote workers.

• One-line Docker deployment for servers and desktop installers for local use.

VoiceStudio shows how much of the creative-AI stack can already move back onto hardware you own.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🗺️ Atlas (GitHub) 3.1k ☆ - source control for coding agents

The Scoop: Atlas gives coding agents version control for their work. Every run produces checkpoints linking commits to the prompts, tool calls and reasoning that created them. Claude Code, Codex, Atlas's own agent and ACP-compatible agents can work against the same codebase with shared memory, making it possible to switch agents without starting over. MIT licensed.

Get started: download the latest release from tryatlas.cc (macOS .dmg), or build from source at github.com/pacifio/atlas.

🐦 TurboFieldfare (GitHub) 6.6k ☆ - Gemma 4 26B in about 2 GB of RAM

The Scoop: TurboFieldfare is a Swift + Metal runtime that runs the 14.3 GB Gemma 4 26B-A4B on Apple Silicon Macs, including 8 GB machines, by keeping a 1.35 GB shared core and KV cache in memory while streaming the required experts from SSD. It is model-specific, with 103 documented optimization experiments. Apache-2.0.

Get started:

🔎 zvec-grep (GitHub) 2.3k ☆ - local-first search for humans and agents

The Scoop: zg combines ripgrep, BM25 and vector search behind one local-first interface, powered by Alibaba's zvec. Index a workspace once, then search it semantically from the terminal or give the same index to a coding agent. Files, indexes and local embedding models never leave your machine.

Get started:

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

// repository of the month - the breakout

The covered repo with the fastest relative star growth on the month, among projects above a certain scale. Where attention accumulates.

📚 book-to-skill - 28k ☆

Repository of the Month · August 2026 · +92% GitHub · Python · MIT

First flagged: PR#39, 2026-07-30, on the radar, at 13k ☆ - “compile a book into an agent skill”.

Since we covered it: from 13k at coverage to 28k today. The award-month climb alone took it from 14k to 27k, +92%. It has not eased off since, averaging +13k a month (+98% a month), +14k total since PR#39, up 2k in the past week. Commit activity is accelerating rather than cooling: 15 commits a week, up 94% on the month before. Thirty-two days separated the first flag from the trophy, the shortest gap we have recorded on this board.

What it does: book-to-skill compiles a book instead of retrieving from one. A single extraction pass distills a technical PDF into named frameworks and decision rules, emitted as a roughly 4,000-token SKILL.md core plus 1,000-token chapters, at about a dollar of model spend per book at current Sonnet pricing. The maintainer’s own measurement puts the resulting “discovery loop tax” at 24 to 51 times fewer tokens than dropping the whole book into context for every question. Parsing is tiered per format: pdftotext, pypdf or docling for PDFs, with docling preserving tables and code blocks, ebooklib for EPUB, Calibre for MOBI, nothing at all for plain text and Markdown. It also generalises well past books, folding architecture decision records, runbooks, brand guidelines or a cluster of papers into one skill you keep updating as new material lands. The converter is MIT and ships zero book content, so you bring your own copy.

Why it took the board: nothing else we track moved this fast in relative terms this cycle, and the more telling evidence sits on our other board. Its understory score has fallen to -45, output 52 against clout 97. In July the shipping ran ahead of the attention. In August the attention did not merely catch up, it lapped it. That crossing is precisely what this award exists to timestamp, and it happened inside four weeks. The work underneath is real if unspectacular: 37 contributors (+13 in the last two weeks), a 94 percent issue-close rate at roughly two days median, and more commits and releases than 52 percent of the repos we track. The bet that matters is architectural, targeting the open Skills spec as a compile target, which turns a personal library into portable infrastructure rather than vendor-locked embeddings.

On the dials: 28k ☆ · +2k last week · 37 contributors · fortnightly releases · last shipped 10 August (v1.4.0) · bus factor 2 · top-author share 38% · Python, MIT · git clone, no published package.

book-to-skill is not just a PDF converter - it is a compiler for institutional knowledge.

// understory of the month - out-shipping its stars

The repos shipping hardest relative to its attention: high output over modest clout. Score is output minus clout. The award for major projects whose following has fallen behind the work.

🤖 Sim Studio - 30k ☆

Understory of the Month · August 2026 · +57 GitHub · homepage · TypeScript · Apache-2.0

First flagged: PR#13, 2025-07-23, below the radar, at 5k ☆ - “Visual AI Agent Workflow Builder”.

Since we covered it: +2k a month (+35% a month), +24k total since PR#13, now at 30k, up just 33 in the past week. That last number is the whole award in one figure. Sim Studio did 159 commits a week this month, steady and slightly up on the month before, and collected thirty-three stars for it. This is also a second trophy: it took the same board in May 2026 at +35, and has since widened the gap to +57, output 93 against clout 36. Repeat winners here are rare, and they tend to share a shape.

What it does: Sim Studio gives teams one workspace to build, deploy and monitor AI agents and workflows, instead of stitching together separate tools for editing, scheduling and logging. It ships connectors to Slack, Notion, HubSpot, Salesforce and databases alongside support for every major LLM, so agents act across systems a business already runs. Self-hosting is a single Docker Compose command, and it will run against local models through Ollama or vLLM, which keeps data and inference in-house for teams that cannot use a managed cloud. Under the hood it is a Turborepo monorepo on Next.js with the Bun runtime, PostgreSQL with pgvector and Drizzle ORM, ReactFlow for the visual editor, Socket.io for realtime updates, and agent code isolated through E2B and isolated-vm with Trigger.dev running scheduled jobs. Notably it is a product you run rather than a library you import, macOS binaries included.

Why it took the board: more commits and releases than 93 percent of the repos we track, weekly releases with v0.8.17 landing on 29 August, 60 contributors, and a README claim of 100,000-plus builders using it. Set that against a star line that moved by thirty-three and an HN peak eight months old, and you have the exact profile this award exists to catch. The watch-item is severe and worth naming plainly: bus factor 1, top-author share 56 percent. Sixty contributors surround it, but one person still carries more than half the commits behind a 159-a-week cadence. That is an extraordinary amount of load for one pair of hands.

On the dials: 30k ☆ · +33 last week · output 93 / clout 36 (award month) · 60 contributors · weekly releases · 159 commits/week · bus factor 1 · top-author share 56% · VC-backed, Y Combinator · last activity today.

Sim Studio is not just a workflow builder - it is 159 commits a week that the star counter has decided to round down to thirty-three.

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

This cycle’s signal came from an unexpected direction: DeepSeek open-sourced its agent harness. Not a model, not a paper - the harness: the UI, the session engine, the plugin runtime that a frontier lab would normally guard as its consumer moat. Read against the past year - OpenClaw sprinting up the fastest star curve GitHub has ever recorded, every lab making its chat app and coding agent the real product surface - it points at one shift. The models keep trading places at the top of the leaderboards, but lock-in never lived in the weights. It lives in the layer that holds your state: conversations, workflows, plugins, memory. And that layer is going open.

That moves the moat. When capability is the product, you pick a lab and live in its app. When capability is a config field - LibreChat speaks to every provider, Superset runs any CLI agent, ai-memory hands your context from Claude Code to Codex mid-task - the state becomes the product, and open source is systematically prying it out of vendor hands.

Back in PR #37 we argued the skill was becoming the package and the coding agent the universal runtime. This issue is the next layer out: not what the agent can do, but where you and the agent live - and who owns the room. That is the lens for this issue: the open harness, the shared workspace, and the memory that moves with you.

🐋 DeepSeek Harness (GitHub) 195.5k ☆ - A frontier lab open-sources the layer you live in

The Scoop: DeepSeek Harness (dsh) is DeepSeek AI’s open-source agent harness, built on one radical premise: everything is a plugin. One npx command boots a local web UI and a full agent runtime on your machine. MIT, in developer preview, and already one of the fastest-climbing repos GitHub has ever seen.

Why It’s a Big Deal

• A frontier lab open-sourcing its harness says the quiet part out loud: models will compete, but the layer that holds your sessions, plugins, and workflows is being handed to the community instead of hoarded as a consumer moat.

• “Everything is a plugin” is an architecture and a governance statement in one: there is no privileged vendor surface, so the community can extend or replace any part of the system, core included.

• Its star curve in preview shows the demand side clearly - developers want an open place to live with AI more than they want another closed app around a great model.

Under the Hood

• Built on Cordis and its “spatiotemporal composability” paradigm, where the entire system composes from hot-swappable plugins on a single runtime.

• npx @deepseek-ai/dsh web starts the web UI locally on port 3080; under it sits a TypeScript monorepo with Python and native layers and 13,000+ commits of very rapid iteration.

• Ships AGENTS.md and CLAUDE.md for coding agents, a public BENCHMARK.md, bilingual docs, and a dsh-plugin GitHub topic as the seed of a plugin ecosystem.

DeepSeek Harness is a frontier lab saying it plainly: the model is the product, and everything around it is a plugin - yours to fork.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🪶 LibreChat (GitHub) 42.4k ☆ - Every model, one self-hosted interface

The Scoop: LibreChat is Danny Avila’s self-hosted AI chat platform that unifies every major provider - and any OpenAI-compatible endpoint - behind a single, privacy-focused interface, with agents, MCP, and enterprise auth built in. MIT, TypeScript.

Why It’s a Big Deal

• It is the neutral ground: while every provider ships an app designed to keep you, one self-hosted interface that speaks to all of them dissolves the switching cost to a dropdown.

• It has quietly outgrown its “ChatGPT clone” origins into a full agent workspace - no-code agents, an agent marketplace, MCP servers, SKILL.md skills, and subagents - proof an open harness can track the frontier feature for feature.

• Multi-user auth, roles, and an admin panel make it the version of AI chat an organization can actually run inside its own walls, data residency included.

Under the Hood

• Endpoints for Anthropic, OpenAI, Google, Bedrock, Azure, and Vertex, plus Ollama, OpenRouter, Mistral, DeepSeek, and any custom OpenAI-compatible API.

• Agents combine MCP tools, file search, artifacts, and a sandboxed code interpreter spanning Python, Node, Go, Rust, and more; subagents run in isolated context windows.

• Production plumbing throughout: OAuth2 and LDAP auth, a browser-based admin panel, and Redis-backed resumable streams that survive dropped connections across tabs and devices.

LibreChat is what the chat app looks like when nobody owns you - every model, one interface, running on your hardware.

🐝 Buzz (GitHub) 30.6k ☆ - Humans and agents in one room, on a relay you own

The Scoop: Buzz is Block’s self-hostable “hive mind” workspace where humans and AI agents share the same channels, repos, and workflows - built as a Nostr relay where every action is a signed event in one log. Apache 2.0, Rust.

Why It’s a Big Deal

• It answers the question agent fleets raise: once agents work like teammates, they need the same room as teammates - not a bot API bolted onto a chat tool that never expected them.

• Signed events give agent work the property it has been missing: a real audit trail. Who did what is cryptography, not a log file someone can edit after the incident.

• The relay is self-hostable, so the workspace itself - not just the client - is yours; Block is betting the human-agent workspace belongs on infrastructure you own.

Under the Hood

• Every message, reaction, review approval, workflow step, and git event (patches as NIP-34 events) lands in one signed event log; channels, search, and UI are projections over it.

• Agents are members, not bots: their own keypairs, their own channel memberships, their own audit trails - scoped by identity the way you would scope a colleague.

• A Rust crate workspace with a Tauri and React desktop app, buzz-cli speaking JSON in and out for LLM tool calls, an ACP harness for Goose, Codex, and Claude Code, and YAML-triggered workflows.

Buzz is the team workspace rebuilt for mixed company - people and agents in one room, every action signed.

🕹️ Superset (GitHub) 13.3k ☆ - The cockpit for your local agent fleet

The Scoop: Superset calls itself the code editor for the AI agents era: a desktop app that orchestrates swarms of Claude Code, Codex, Cursor, and any other CLI agent in parallel, each in its own isolated git worktree. Source-available under ELv2.

Why It’s a Big Deal

• The bottleneck has moved from writing code to supervising the agents that write it, and Superset is a cockpit built for exactly that job - monitor everything, jump in only where needed.

• Worktree isolation is the unglamorous idea that makes parallel agents safe: every task gets its own branch and working directory, so ten agents can run without shared-state carnage.

• It is harness-neutral by design - if it runs in a terminal, it runs on Superset - which makes it switching-cost insurance for your entire coding stack.

Under the Hood

• Runs 10+ agents simultaneously with automatic status tracking and notifications when an agent is blocked or done.

• A built-in terminal, diff viewer, and editor for reviewing changes in place, plus one-click handoff of any workspace to your IDE; presets automate env setup and dependency installs per worktree.

• Electron, Bun, and React with tRPC and Electric sync underneath; first-class presets for Claude Code, Codex, Cursor, Gemini CLI, Droid, OpenCode, and friends.

Superset is what the IDE becomes when you stop writing the code and start running the crew.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🕸️ code-graph-rag (GitHub) 4.8k ☆ - Your monorepo as a knowledge graph your agent can walk

The Scoop: code-graph-rag parses a multi-language codebase with Tree-sitter into a Memgraph knowledge graph, then lets you query, edit, and optimise it in plain English - AST-surgical patches with diff previews, dead-code hunts along call edges, even runtime traces merged into the graph. Runs as an MCP server, so your coding agent gets a map of the codebase instead of grep in the dark. By vitali87.

Get started:

cgr start --repo-path /path/to/your/repo --update-graph

🧠 ai-memory (GitHub) 4.5k ☆ - Long-term memory that moves between agent vendors

The Scoop: ai-memory is Fabio Akita’s Rust answer to agent amnesia and vendor lock-in in one: lifecycle hooks capture every session and compile it into a plain-markdown, git-versioned wiki - grep-able, Obsidian-openable, rsync-backed. Quit Claude Code mid-task, start Codex in the same directory, and the next agent gets a “where you left off” handoff. Around twenty harnesses supported. MIT.

Get started:

akitaonrails/ai-memory Docker image, then ai-memory install-mcp --client claude-code --apply

🪵 Maka (GitHub) 3.9k ☆ - A local-first agent workspace where the log is the runtime

The Scoop: Maka is an Apache-incubating, local-first agent workspace built on one idea: the log is the runtime. Every model message, tool call, and result is a recoverable execution fact in an event log; sessions, UI, and context are just projections over it, so nothing your agent did is ever disposable. Data stays on your machine, and you bring your own model - cloud API, local, or gateway. Desktop, TUI, and an eval harness in one. Apache 2.0.

Get started:

npm ci && npm run dev from source

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

On July 30, AI infrastructure company Nscale agreed to acquire Anyscale for roughly $1.65 billion. Anyscale is the company behind Ray, the widely used open-source distributed computing framework much of the ML world already runs on. The deal folds Ray’s commercial layer directly into a neocloud’s compute stack.

That’s vertical consolidation, not just a funding round. Nscale sells GPU capacity; Anyscale sells the orchestration deciding how it gets used. One roof means the company renting you hardware now owns the scheduling layer too. The constraint shifts from “can I get compute” to “whose orchestration am I locked into.”

That is the lens for this issue: when a compute-and-orchestration stack gets vertically owned, the projects worth watching are the ones that stay deliberately out of anyone’s stack.

📡 Dask (GitHub) 13.9k ☆ - distributed compute for Python that answers to NumFOCUS, not a neocloud

The Scoop: Dask is a flexible parallel computing library for Python, scaling pandas, NumPy, and scikit-learn-style workflows across a cluster, or just your laptop’s cores, using nearly the same code.

Why It’s a Big Deal

• Genuinely neutral governance: fiscally sponsored by NumFOCUS, not owned by a single backer, so no acquisition quietly changes who controls the roadmap.

• Predates Ray by years as Python’s original answer to “run this bigger than one machine,” still the default reach across the PyData world.

• The counter-example to a neocloud buying an orchestration layer: infrastructure built to be nobody’s exclusive asset from day one.

Under the Hood

• Task graph execution: code compiles to a DAG, then a scheduler runs it, so scripts scale from laptop to thousand-node cluster unchanged.

• Distributed scheduler with a real-time diagnostic dashboard, making cluster bottlenecks visible rather than a black box.

• Native integration with pandas, NumPy, scikit-learn, and XArray, rather than a parallel Dask-only ecosystem.

Dask is not just a Ray alternative, it is proof vendor-neutral is a governance decision, not a marketing line.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🔍 Open Code Review (GitHub) 20.0k ☆ - Alibaba’s internal reviewer, now open source

The Scoop: Open Code Review is an AI code review CLI, Alibaba’s internal review assistant for two years before being open-sourced.

Why It’s a Big Deal

• Beats general-purpose agents on precision and F1 across 200 real PRs, at roughly a ninth of the token cost.

• Delegation mode runs the review with your own agent’s model, no separate API key needed.

• Validated at Alibaba’s internal scale against millions of real defects before being open-sourced.

Under the Hood

• Hybrid architecture: deterministic engineering (file selection, bundling, rule matching) handles what must not go wrong, an LLM agent handles the rest.

• ocr scan reviews whole files or directories with no diff needed, useful for auditing unfamiliar codebases.

• Built-in ruleset covering NPE, thread-safety, XSS, and SQL injection, compatible with OpenAI and Anthropic models.

Open Code Review is not just a linter with an LLM bolted on, it is proof review quality comes from engineering constraints, not just a bigger model.

🧠 TencentDB Agent Memory (GitHub) 19.6k ☆ - memory that belongs to the team

The Scoop: TencentDB Agent Memory is a team-level memory hub, turning conversations, docs, and code into four governed asset types shared across a team’s agents rather than trapped in one person’s history.

Why It’s a Big Deal

• Most memory tools solve the personal case. This targets the real gap: five developers whose agents each relearn the same lesson is four wasted lessons.

• Real benchmarks: up to 61% lower token usage and a 51% relative pass-rate gain on OpenClaw across WideSearch, SWE-bench, and AA-LCR.

• ACL-based sharing by team, user, and agent means memory gets governed, not just accumulated.

Under the Hood

• Four asset types, Chat Memory, Skill, Wiki, Code-Graph, bound to agents through Fixed Binding plus ACL.

• Symbolic short-term memory condenses verbose tool logs into a compact Mermaid graph with node-level tracing back to raw evidence.

• Layered long-term memory runs Conversation to Atom to Scenario to Persona, a semantic pyramid instead of a flat vector dump.

TencentDB Agent Memory is not just a bigger context window, it is plumbing for memory as a durable, governed team asset rather than one agent’s session exhaust.

🔁 Prime Agent (GitHub) 13.4k ☆ - the agent that rewrites its own instructions

The Scoop: Prime Agent is a self-improving coding agent built around the Recursive Language Model, context as a variable, sub-agents as function calls inside a persistent REPL, plus a Continual Harness it refines as it works.

Why It’s a Big Deal

• /refine applies small, evidence-backed updates to its own harness state, never touching the immutable base prompt, a genuinely different answer to “how does an agent improve” than fine-tuning.

• Reports 95.5% on ARC-AGI-3 with Opus 5, against a 95.4% human expert baseline, on a model that scores far lower in other harnesses.

• Daemon-backed sessions and direct agent-to-agent messaging point toward agents as long-running processes, not single chat sessions.

Under the Hood

• A persistent IPython REPL is the single model-facing tool, files, shell, and subagents all happen through code.

• Bounded autonomous mode runs within configured turn, token, and time budgets, with user-defined quality gates.

• Built on Mario Zechner’s pi harness rather than a ground-up TUI, freeing effort for the RLM and Continual Harness layers.

Prime Agent is not just another terminal coding agent, it is a bet that the harness, not the model, is where the next real gains hide.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

📦 AgentENV (GitHub) 3.1k ☆ - the sandbox platform powering Kimi K3's RL training

The Scoop: AgentENV is a distributed platform for running agent environments at scale, built to power agentic RL training for Kimi K3, scaling Firecracker microVMs with snapshot-backed boot times under 50ms.

Get started:

☁️ Cloudflare OS (GitHub) 7.6k ☆ - the internal AI operating system Cloudflare just gave away

The Scoop: Cloudflare OS is the “operating system” for AI productivity that Cloudflare built and runs internally across engineering, sales, and everything in between, now open source so any company can fork it into their own.

Get started:

🩺 iFixAi (GitHub) 8.3k ☆ - an independent auditor for your AI agents

The Scoop: iFixAi audits AI agents independently of the model or harness that built them, running dozens of inspections across five pillars and handing back an A-to-F scorecard on whether the agent is actually doing what it’s supposed to.

Get started:

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

// repository of the month - the breakout

The covered repo with the fastest relative star growth on the month, among projects above a certain scale. Where attention accumulates.

🔀 OmniRoute - 37k ☆

Repository of the Month · July 2026 · +105% GitHub · homepage · TypeScript · MIT

First flagged: PR#38, 2026-07-15, above the radar, at 18k ☆ - “one endpoint, every model, none of the lock-in”.

Since we covered it: from 18k at coverage to 37k today. The award-month climb alone took it from 17k to 36k, +105%. It hasn’t eased off since, averaging +31k a month (+176% a month), +19k total since PR#38, up 7k in the past week. Commit activity is accelerating rather than cooling: 259 commits a week, up 129% on the month before.

What it does: OmniRoute sits in front of every model a coding agent might call and turns model choice into a runtime decision instead of a vendor commitment. One endpoint routes to 290-plus providers and 500-plus models (Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax and more), so if a provider rate-limits, fails, or gets pricey, the request slides to the next one in a fallback chain instead of breaking the workflow. It stacks token compression and a subscription-first routing tier on top, treating cost as infrastructure rather than an afterthought, and bundles an MCP server and A2A support so one gateway can serve two dozen-plus agents through a single integration point.

Why it took the board: nothing else we track moved this fast in relative terms this cycle, and the pace is backed by real infrastructure work, not just hype: 353 contributors (+85 in the last two weeks), 64k npm downloads a week, and a 99 percent issue-close rate at roughly a day median. It ships as an npm package, a multi-arch Docker image, and an Electron desktop app, all under one MIT license.

On the dials: 37k ☆ · +7k last week · 353 contributors · weekly releases · last shipped today · TypeScript, MIT · npm, Docker, Electron.

OmniRoute is not just an AI gateway - it is the insurance policy every agent stack didn’t know it was missing until a provider went down.

// understory of the month - out-shipping its stars

The repos shipping hardest relative to its attention: high output over modest clout. Score is output minus clout. The award for major projects whose following has fallen behind the work.

🎛️ Reflex - 29k ☆

Understory of the Month · July 2026 · +44 GitHub · homepage · Python · Apache-2.0

First flagged: PR#14, 2025-08-06, on the radar, at 24k ☆ - “Declarative Development Environments”.

Since we covered it: +360 stars a month (+1% a month), +4k total since PR#14, now at 29k, up just 24 in the past week. The site’s own status tag calls it plainly: FLATLINED. Star growth has essentially stopped. Worth noting honestly, the live output/clout split has drifted since the July award, from an implied output 84 / clout 40 in the award month to output 84 / clout 53 as of today’s read - clout ticking up slightly even as growth stays flat in absolute terms.

What it does: Reflex lets developers build full web apps in pure Python: UI, state, event handlers, and routing all defined in one language, with no separate frontend stack to maintain. Under the hood it compiles down to FastAPI and Next.js, abstracted away from the developer, and ships hot reload, form and state handling, and native async support. Deployment runs through the CLI, either to Reflex Cloud or your own infrastructure.

Why it took the board: a four-year-old, YC-backed (W23) framework kept a commit-and-release output of 84 out of 100 this month while its star count barely moved at all, the exact profile this award exists to catch. 208 contributors, weekly releases, and 105k PyPI downloads a week say the usage is real even where the GitHub attention has gone quiet. The watch-item is concentration: a handful of maintainers still carry most of the recent commits (bus factor 3, top-author share 26 percent).

On the dials: 29k ☆ · +24 last week · output 84 / clout 40 (award month) · 208 contributors · weekly releases · top-author share 26% · bus factor 3 · last activity yesterday.

Reflex is not just a Python web framework - it is a reminder that a flat star chart and a dead project are not the same thing.

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Nine months ago, Agent Skills was a Claude Code feature. Today it is a cross-vendor standard: Anthropic published the spec as an open standard at agentskills.io in December, OpenAI made skills a core capability of the Codex app in February, and by June roughly 40 skills-compatible products sat on the official showcase - Copilot, Cursor, Gemini CLI and VS Code among them. Governance has moved sideways too: the Linux Foundation’s Agentic AI Foundation, home to MCP and AGENTS.md, crossed 190 member organizations in May. And with scale came the audit: Snyk’s ToxicSkills research found prompt injection in 36% of skills tested, and a scan of 22,000-plus published skills surfaced six figures worth of issues.

Put those together and a pattern emerges. Models keep consolidating upward, but know-how is standardizing outward - procedural knowledge packaged as folders of markdown that any agent can load. Once the format for expertise is settled and portable, the differentiator stops being which lab’s model you rent and becomes how well you engineer everything around it: context, tools, memory, evals.

That is the lens for this issue: when know-how becomes the artifact, the OSS that matters is the knowledge itself - the textbooks, the code graphs, the installable skills, and the sandboxes that keep untrusted skills honest. Which is why the biggest agent repo trending right now is not a framework. It is a book.

📖 ai-agent-book (GitHub) 26.1k ☆ - an agent-engineering degree in one repo

The Scoop: OmniRoute is a self-hosted AI gateway that exposes a single OpenAI-compatible endpoint and routes it to more than 230 providers, 50 of them with free tiers. Point Claude Code, Codex, Cursor or Cline at one local URL and OmniRoute decides which model actually answers.

Why It’s a Big Deal

• It open-sources the harness craft. The book’s thesis is that everything around the model - context engineering, tool design, evaluation - is where the real competitive edge lives, and nearly every claim comes with an ablation experiment you can run yourself instead of a slide you have to believe.

• It treats agent engineering as a discipline with a curriculum: context engineering, memory and RAG, tools and MCP, coding agents, evals, post-training, self-evolution, multimodal, multi-agent. Each chapter is a lab, not a lecture.

• It is documentation-as-code at book scale: full text and figures under an open license, figures generated by scripts, errata and new chapters arriving as pull requests. The knowledge frontier is publishing in public, and increasingly not in English first.

Under the Hood

• Ten chapters plus introduction and afterword in Markdown, compiled to PDF via pandoc and xelatex; every diagram is generated by a Python script checked into the repo.

• Companion projects per chapter: prompt-injection attack/defense matrices, KV-cache-friendly context design, agentic RAG pipelines, MCP tool servers, a production-grade coding agent with 17 tools, and eval harnesses wired to GAIA, SWE-bench and Terminal-Bench.

• Projects come in three honesty tiers - runnable out of the box, reproduction guide, or design doc - with external benchmarks and training frameworks pulled in via a clone script. Apache-2.0.

ai-agent-book is not a tutorial - it is the harness-engineering canon being written in the open, experiments included.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🕸️ code-review-graph (GitHub) 27.5k ☆ - blast-radius analysis for every AI code review

The Scoop: code-review-graph parses your repository into an AST-level knowledge graph with tree-sitter, stores it in local SQLite, and serves it to coding agents over MCP. When a diff lands, the graph computes the blast radius - every caller, dependent and test the change could touch - so the agent reads only that, instead of re-reading the repo.

Why It’s a Big Deal

• It turns code review into a graph query: 8.2x average token reduction across six real repos in its own benchmarks, up to 49x on a Next.js-scale monorepo, with 100% recall on actually impacted files.

• It is agent-agnostic to an almost aggressive degree - a single install command auto-configures 14 platforms, from Codex and Claude Code to Cursor, Windsurf, Zed and Copilot. The graph is shared infrastructure, not a plugin for one vendor.

• It benchmarks honestly: the README publishes its own sub-1x failure case on small single-file changes and names its weak spots (search ranking, flow detection) right next to the wins. That culture deserves stars on its own.

Under the Hood

• Tree-sitter grammars for 24 languages plus Jupyter and Databricks notebooks; nodes and edges live in a local SQLite file, no external database, no cloud dependency.

• Incremental updates via git hooks and SHA-256 diffing re-index a 2,900-file project in under two seconds; a multi-repo daemon keeps graphs fresh for editors without hook support.

• 28 MCP tools (impact radius, budgeted graph traversal, hub and bridge detection, dead-code refactor previews) plus five workflow prompts, D3 visualization and GraphML/Neo4j/Obsidian exports. MIT-licensed.

code-review-graph shows the local code graph maturing from a context trick into proper review infrastructure.

📚 book-to-skill (GitHub) 12.4k ☆ - compile a book into an agent skill

The Scoop: book-to-skill turns any technical book, document folder or paper stack into an Agent Skills-standard skill: a compact SKILL.md of core mental models, one file per chapter loaded on demand, plus glossary, patterns and cheatsheet. The same generated skill runs in Claude Code, GitHub Copilot CLI and Amp.

Why It’s a Big Deal

• It compiles knowledge instead of retrieving it. One extraction pass distills a book into named frameworks and decision rules; the maintainer’s measured “discovery loop tax” puts it at 24-51x fewer tokens than dumping the book into context per question.

• It targets the open Skills spec as a compile target, so your library becomes portable infrastructure rather than vendor-locked embeddings - the clearest signal yet that the standard is real.

• It goes well beyond books: fold architecture decision records, runbooks, brand guidelines or a cluster of papers into a single skill and keep updating it as new material lands. Internal knowledge becomes an installable capability.

Under the Hood

• Pure-Python extraction with tiered parsers per format: pdftotext, pypdf or docling for PDFs (docling preserves tables and code blocks), ebooklib for EPUB, Calibre for MOBI; plain text and Markdown need no deps.

• Output is a roughly 4,000-token SKILL.md core plus 1,000-token chapters; converting a full book costs about a dollar of model spend at current Sonnet pricing.

• Ships its own measurement and validation tooling (discovery_tax.py, per-host skill validator); MIT-licensed converter that includes zero book content - you bring your own copy.

book-to-skill treats reading as a build step - pay the extraction cost once, load kilobytes forever.

🎯 i-have-adhd (GitHub) 13.4k ☆ - the skill that stops your agent burying the answer

The Scoop: i-have-adhd is a tiny cross-agent skill that reshapes coding-agent output: lead with the next action, number the steps, end with one concrete next step, kill the preamble and the “Hope this helps!”. Ten rules in a SKILL.md, installable in Claude Code, Codex, Cursor and Gemini CLI.

Why It’s a Big Deal

• It proves skills are becoming the UX layer of agents: ten lines of behavioral rules change the daily experience more than most model swaps do, and 13k developers starred a markdown file to say so.

• Distribution runs through plugin marketplaces, not git clones - one command installs it and keeps it updated across hosts. Skills are starting to behave like packages, registry semantics included.

• The customization story is fork-to-tune: the SKILL.md is the entire product, so editing the rules and swapping in your fork is the whole workflow. Prompt engineering with version control and a changelog.

Under the Hood

• One repo ships manifests for Claude Code plugins, Codex plugins, Cursor skills and Gemini CLI extensions, plus hooks and an eval suite to check the style actually holds.

• The ten rules are loosely adapted from The Adult ADHD Tool Kit, rewritten for how an LLM should respond rather than how a human should plan a day.

• MIT-licensed, with READMEs in English, Chinese, Japanese and Korean - a decent proxy for where the demand is coming from.

i-have-adhd is what infrastructure looks like now: a hundred lines of markdown at the top of the charts.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🌳 adhd (GitHub) 2.7k ☆ - tree-of-thought with the critic switched off

The Scoop: adhd (yes, same name, different repo) is a skill and TypeScript library on the Claude Agent SDK that makes agents think wide before deep: it fans out parallel, fully isolated ideation branches under different cognitive frames (regulator, speedrunner, 3am on-call, zero budget), then a separate critic pass scores every idea, flags the traps with reasons, and deepens only the survivors. About 10 LLM calls per run - built for design decisions, not lookups.

Get started: npm install -g adhd-agent, then adhd “design a rate limiter that survives a leader election”

🔒 nono (GitHub) 3.3k ☆ - sandbox any agent in seconds

The Scoop: nono, from the team behind Sigstore, is a least-privilege sandbox for Claude Code, Codex, OpenCode and friends with no daemon, no container and no VM - pull a profile from its registry and the agent sees your working directory and nothing else. Its sharpest idea: delegated tools like git, gh and curl run in their own child sandboxes with separate credentials, invocation policies and L7 API filtering, so the agent can call a tool but never widen its permissions. Exactly the primitive a skills ecosystem with a 36% injection rate needs.

Get started: curl -fsSL https://nono.sh/install.sh | sh, then nono run --profile nolabs-ai/claude -- claude

🗺️ GeoLibre (GitHub) 3.9k ☆ - a cloud-native desktop GIS with an agent in the toolbar

The Scoop: GeoLibre, from the opengeos project, is a lightweight desktop GIS built on Tauri v2, React, MapLibre GL JS and DuckDB-WASM Spatial - it loads GeoJSON, GeoParquet, GeoPackage and Shapefiles locally, with styling, attribute tables and a processing toolbox. The plugin system already ships a GeoAgent integration alongside swipe, lidar and street view: an early look at domain software growing native agent surfaces instead of waiting for a chatbot sidebar.

Get started: git clone https://github.com/opengeos/GeoLibre && cd GeoLibre && npm install && npm run tauri:dev

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

The recency here is the point. This week, on July 15, Continue’s cloud goes dark: Cursor acquired the open-source coding assistant in June, switched its main repo to read-only, and told users to export their data by that date or lose it. That follows OpenAI’s spring move to buy Astral, the team behind uv and ruff - Python tooling with north of 120 million downloads a month - a deal still working through regulatory approval. In a single quarter, the tools developers type into all day have changed hands.

That matters because the toolchain is the new distribution. Whoever owns the linter, the package manager and the agent runner owns the developer’s daily habit, along with the telemetry and defaults that ride with it. The licenses stay open - uv and ruff keep their MIT and Apache terms - but stewardship now sits inside a frontier lab whose incentives point back at its own models.

That is the lens for this issue: when an upstream commercializes, developers reach for the primitive that stays neutral - one that talks to every provider, runs on your own subscription, and keeps your data on your machine. As the toolchain consolidates upward, the OSS that matters is the layer that refuses to pick a side.

🔀 OmniRoute (GitHub) 16.4k ☆ - one endpoint, every model, none of the lock-in

The Scoop: OmniRoute is a self-hosted AI gateway that exposes a single OpenAI-compatible endpoint and routes it to more than 230 providers, 50 of them with free tiers. Point Claude Code, Codex, Cursor or Cline at one local URL and OmniRoute decides which model actually answers.

Why It’s a Big Deal

• It reframes model choice as a runtime decision rather than a vendor commitment. If a provider rate-limits, fails, or gets expensive, the request slides to the next model in a fallback chain instead of breaking the workflow.

• It is the cleanest answer to lock-in anxiety: one endpoint, your keys, your fallback rules, and no dependence on whichever lab happens to own your coding agent this quarter.

• It treats cost as infrastructure rather than an afterthought - stacked token compression and a subscription-first routing tier push spend down without touching the calling code.

Under the Hood

• Ships as an npm package, a multi-arch Docker image, and an Electron desktop app; the gateway runs locally at localhost:20128/v1.

• Translates between OpenAI, Claude and Gemini API shapes, with circuit breakers, per-provider retries and an optional Qdrant plus sqlite-vec memory layer.

• Bundles an MCP server and A2A support, so one gateway serves 24-plus agents through a single integration point. MIT-licensed.

OmniRoute is not just a proxy in front of some APIs - it is a neutrality layer that keeps model choice in the developer’s hands rather than the lab’s.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🧠 codebase-memory-mcp (GitHub) 27.5k ☆ - your repo as a local knowledge graph

The Scoop: codebase-memory-mcp indexes an entire repository into a persistent knowledge graph with tree-sitter, then serves it to coding agents over MCP. Instead of grepping files one at a time, the agent queries structure - call chains, routes, dependencies - and answers with a fraction of the tokens.

Why It’s a Big Deal

• It reframes code context as a graph to traverse rather than a pile of files to re-read, which is where most of an agent’s token budget quietly disappears.

• It runs entirely local with zero telemetry - the kind of primitive that gets more appealing exactly as agent vendors consolidate.

• It is agent-agnostic by design, wiring itself into eleven assistants from a single install rather than betting on one ecosystem.

Under the Hood

• Single static binary, zero runtime dependencies, on macOS, Linux and Windows; tree-sitter grammars for 158 languages compiled in.

• RAM-first pipeline with LZ4 compression and in-memory SQLite; claims a full index of the Linux kernel in about three minutes and sub-millisecond queries.

• 14 MCP tools including call-graph tracing, git-diff impact analysis and dead-code detection; signed releases with SLSA 3 provenance. MIT-licensed.

codebase-memory-mcp shows how agent context is moving below the application layer - into a shared local index any assistant can read.

🎙️ meetily (GitHub) 23.8k ☆ - a meeting notetaker that never leaves your machine

The Scoop: meetily is a self-hosted meeting assistant that records, transcribes and summarizes calls entirely on your own hardware. Transcription runs locally through Whisper or Parakeet; summaries go through Ollama, or your own Claude or Groq key if you prefer.

Why It’s a Big Deal

• It puts data ownership first in a category built almost entirely on cloud capture - nothing leaves the device unless you pick a remote model.

• It reframes the notetaker as infrastructure you host rather than a SaaS seat you rent, which matters as meeting data quietly becomes training data somewhere upstream.

• Bring-your-own-model support means the same app runs fully offline or plugged into a frontier model, without locking you to either.

Under the Hood

• Single Tauri application: Rust backend, Next.js frontend; runs on macOS, Windows and Linux.

• GPU acceleration via Metal and CoreML on macOS, CUDA and Vulkan elsewhere; reuses whisper.cpp and an ONNX build of Parakeet.

• Handles simultaneous mic and system audio with ducking, across 90-plus transcription languages. MIT-licensed Community Edition.

meetily is not just an Otter alternative - it is a bet that the most sensitive data in your day belongs on hardware you control.

🐋 orca (GitHub) 16.4k ☆ - run a fleet of agents on your own subscriptions

The Scoop: orca is an agentic development environment for running coding agents in parallel. Each agent - Claude Code, Codex, OpenCode and others - runs in its own git worktree on your own subscription, and you compare and merge the results from one place.

Why It’s a Big Deal

• It reframes the coding agent as something you orchestrate rather than something you are locked into, running several side by side on accounts you already pay for.

• Parallel worktrees turn agent choice into an experiment: fan one prompt across models, keep the winner, discard the rest.

• The desktop-plus-mobile design signals that agent supervision is becoming its own workflow, not a feature bolted onto an editor.

Under the Hood

• Electron desktop app, roughly 97% TypeScript, with a Swift mobile companion; macOS, Windows and Linux.

• Agent-agnostic - works with any CLI agent that runs in a terminal, with an account switcher and usage tracking built in.

• Scriptable CLI (orca worktree create, snapshot, click, fill) and a headless orca serve mode for remote servers. MIT-licensed.

orca is a strong example of tooling moving from single-agent apps toward vendor-neutral agent orchestration.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

⚡ FlashInfer (GitHub) 5.8k ☆ - the neutral kernel layer under your inference stack

The Scoop: FlashInfer is a GPU kernel library and generator for LLM serving, with unified APIs for attention, GEMM and MoE that auto-select among FlashAttention, cuDNN, CUTLASS and TensorRT-LLM backends. It is the neutral kernel layer now sitting beneath vLLM, SGLang and TensorRT-LLM.

Get started: pip install flashinfer-python

📓 Reor (GitHub) 8.6k ☆ - a private, local-first AI note-taking brain

The Scoop: Reor is a private, local-first personal knowledge management app: every note you write is chunked, embedded and linked to related notes automatically, with RAG-powered Q&A over your own corpus. Models run locally through Ollama by default, or you point it at any OpenAI-compatible endpoint.

Get started: download the desktop app from reorproject.org, then Settings → Add New Local LLM to pull a model through Ollama.

🔌 TanStack AI (GitHub) 2.7k ☆ - a type-safe, provider-agnostic AI SDK

The Scoop: TanStack AI is a type-safe, provider-agnostic TypeScript SDK for chat, tool-calling agents and multimodal apps, with pluggable adapters for OpenAI, Anthropic, Gemini, Ollama and more. It is the TanStack team’s vendor-neutral answer to the Vercel AI SDK.

Get started: pnpm add @tanstack/ai @tanstack/ai-openai

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

This cycle’s signal: the Agent Skills open standard. Anthropic published SKILL.md as an open spec, and within months competing tools - OpenAI’s Codex, Google’s Gemini CLI, Cursor, Microsoft’s VS Code, AWS’s Kiro, Block’s Goose - were all reading the same folder of instructions from the same directory structure. Marketplaces appeared almost overnight, and by spring the number of published skills ran into the hundreds of thousands. Read alongside a year of coding agents that can run shell commands, edit files, and execute code, it points at one shift. The coding agent is no longer a tool for writing code. It is a general worker you specialize per task by handing it a skill.

That moves the unit of capability. For years, giving software a new ability meant shipping a library to import or an API to call. Now it can mean writing a markdown file. A SKILL.md is procedural knowledge - how to cut a video, how to find an IDOR, how to deploy to a cloud - packaged as instructions and a few scripts, loaded on demand. The agent is the runtime, the skill is the package, and capability ships as text.

Back in PR #36 we argued the agent had become a process that stays up. This issue is one step past that: not whether it keeps running, but what it learns to do once it does. That is the lens for this issue: the coding agent as universal worker, and the skill as the way it picks up a trade.

🎬 OpenMontage (GitHub) 30k ☆ - A coding agent reforged into a full video production studio

The Scoop: OpenMontage turns any AI coding assistant - Claude Code, Cursor, Codex, Copilot, Windsurf - into an end-to-end video studio. You describe what you want in plain language and the agent runs research, scripting, asset generation, editing, and final composition through a pipeline of skills. AGPL-3.0, by calesthio AI Labs, mostly Python.

Why It’s a Big Deal

• It is the purest expression of this issue’s thesis: there is no bespoke “video agent” here, just a general coding agent plus a folder of skills. The capability lives in instructions, not in a binary.

• It treats video production like engineering - twelve pipelines, scored provider selection, quality gates, and audit trails - so the agent works like a studio rather than a prompt-to-clip toy.

• It makes real footage, not just animated stills - the documentary pipeline builds a CLIP-searchable corpus from open archives and cuts an actual timeline, which is the line most “free AI video” stacks quietly never cross.

Under the Hood

• An agent-first architecture with no code orchestrator: the coding agent reads YAML pipeline manifests and Markdown stage-director skills, calls 52 Python tools, self-reviews, checkpoints state to JSON, and pauses for your approval at each creative decision.

• A three-layer knowledge stack - tools and pipeline definitions for what exists, skills for how OpenMontage wants them used, and external knowledge packs for how each provider works - with 500+ agent skills in total.

• Scored provider selection across seven dimensions over 14 video models, 10 image models, and 4 TTS engines (FLUX, Veo, Kling, WAN, Piper and more), plus pre-compose and post-render gates that run ffprobe, frame sampling, and audio analysis before you ever see a frame.

OpenMontage is what happens when the coding agent stops shipping code and starts shipping cuts - a full production studio that lives entirely in a folder of skills.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

👁️ supervision (GitHub) 45.5k ☆ - The reusable toolkit that gives an agent eyes

The Scoop: supervision is Roboflow’s model-agnostic computer vision toolkit - the reusable building blocks for detection, tracking, annotation, and dataset wrangling that sit between any vision model and a working application. MIT, Python.

Why It’s a Big Deal

• An agent that has left the text box still needs hands for pixels, and supervision is the most-reached-for set of them - plug in any detector or segmenter and get back a clean, uniform set of detections.

• It is quietly retrofitting for the agent era: the repo now ships AGENTS.md and CLAUDE.md, so a coding agent can learn how to use the library the same way a human would.

• It turns one-off vision scripts into composable primitives - zones, trackers, annotators, dataset converters - which is exactly the shape an agent needs to assemble a pipeline without reinventing the plumbing.

Under the Hood

• A model-agnostic detections API with connectors for Ultralytics, Transformers, MMDetection, Inference, and RF-DETR, plus highly customizable annotators for boxes, masks, and labels.

• Trackers, line and zone counters, and dwell-time and speed-estimation utilities, alongside dataset tools to load, split, merge, and save COCO, YOLO, and Pascal VOC.

• The 0.28 release adds CompactMask and SAM3 support, keeping the toolkit current with the latest segmentation models.

supervision is the toolkit a generalist agent reaches for the moment the task stops being text on a screen and starts being pixels in a frame.

🦉 strix (GitHub) 27.8k ☆ - A coding agent handed a hacker’s toolkit

The Scoop: Strix are autonomous AI agents that behave like real hackers - they run your code dynamically, find vulnerabilities, and prove them with working proof-of-concepts instead of flooding you with false positives. Apache-2.0, Python, sandboxed in Docker.

Why It’s a Big Deal

• It is the same generalist agent pointed at a different trade: give it a security toolkit and it becomes a penetration tester that validates findings, not a scanner that guesses.

• Real proof-of-concepts are the whole point - it reproduces a vulnerability before reporting it, which is the difference between a fixable ticket and static-analysis noise.

• A “graph of agents” turns one tester into a team - specialized agents split across attack surfaces and run in parallel, the way a real red team would.

Under the Hood

• A full toolkit out of the box: an HTTP proxy, multi-tab browser automation for XSS and auth flows, interactive shells, a Python runtime for custom exploits, recon and OSINT, and static plus dynamic code analysis.

• Multi-agent orchestration that distributes specialized agents across assets and shares discoveries between them as they go.

• CLI-first with a headless mode and GitHub Actions integration, so a pull request can be pentested and auto-fix PRs proposed; built on LiteLLM, Caido, Nuclei, Playwright, and Textual.

strix is what a coding agent becomes when you hand it a hacker’s toolkit instead of a feature request.

✂️ video-use (GitHub) 12.4k ☆ - Edit video with a coding agent, by reading it instead of watching it

The Scoop: video-use lets a coding agent edit raw footage into a finished cut. Drop your takes in a folder, chat with the agent, get final.mp4 back. The trick: the model never watches the video, it reads a structured view of it. MIT, from the Browser Use team, shipped as a skill.

Why It’s a Big Deal

• It carries the browser-use insight into a new medium - give the LLM a structured representation, a transcript plus an on-demand composite rather than a 30,000-frame firehose, and editing becomes a reasoning task instead of a vision-bandwidth problem.

• It ships as a skill you register with Claude Code, Codex, or any shell agent, so the editing craft travels with the agent rather than living locked inside a separate app.

• It closes its own loop - the agent self-evaluates the rendered output at every cut boundary and re-renders until it passes, so you only see work that already checked itself.

Under the Hood

• Layer one is an ElevenLabs Scribe transcript with word-level timestamps, speaker diarization, and audio events, packed into a roughly 12KB markdown file that serves as the agent’s primary reading surface.

• Layer two is a timeline view, an on-demand filmstrip plus waveform plus word-label composite the agent renders only at ambiguous decision points.

• A Transcribe to Pack to Reason to EDL to Render to Self-Eval pipeline on FFmpeg, with filler-word cuts, automatic color grading, 30ms audio fades, burned subtitles, and session memory persisted to project.md.

video-use proves the move that makes all of this work - give the agent a structured reading of the world, not the raw firehose, and let a skill do the rest.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

☁️ agents-cli (GitHub) 3.9k ☆ - A skill suite that teaches a coding agent to build other agents

The Scoop: agents-cli is Google’s CLI and skill set that turns any coding assistant into an expert at scaffolding, evaluating, deploying, and governing agents on the Gemini Enterprise Agent Platform. It is explicitly a tool for coding agents rather than a coding agent itself - the clearest sign yet that “install a skill” is becoming how capability ships. Works with Claude Code, Codex, Antigravity CLI, and any other coding agent. Apache-2.0.

Get started: npx skills add google/agents-cli (or uvx google-agents-cli setup)

🎨 astryx (GitHub) 1.5k ☆ - Meta’s design system, rebuilt as one system for humans and agents

The Scoop: astryx is the design system that grew inside Meta over eight years - 13,000+ apps, 150+ components - now open-sourced as React plus StyleX with a deliberate twist: the API, docs, and CLI are designed so a person and an AI assistant build the exact same way, from the same reference. It ships a CLAUDE.md and treats “agent ready” as a first-class principle, not a bolt-on. MIT, in beta.

Get started: npm install @astryxdesign/core @astryxdesign/theme-neutral then npm install -D @astryxdesign/cli

🐑 herdr (GitHub) 8.8k ☆ - A terminal-native multiplexer for herding many agents at once

The Scoop: herdr is a single Rust binary that lives inside your terminal and gives you workspaces, tiled panes, automatic agent detection, and at-a-glance state for every coding agent you have running - blocked, working, done, or idle. Once you are running a fleet of specialized agents, you need somewhere to watch them, and herdr is that surface. Agents can drive it too, through a local socket API and its own SKILL.md. Fittingly, it was built almost entirely by the agents it manages. AGPL-3.0.

Get started: curl -fsSL https://herdr.dev/install.sh | sh

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

This cycle’s signal came out of Temporal’s Replay 2026: durable execution is being repositioned as agent infrastructure, with serverless workers and first-class integrations for the Google ADK and the OpenAI Agents SDK. Read alongside a year of background-agent launches - coding agents that run for hours, schedulers that fire agents while you sleep - it points at one shift. The agent is no longer a request you wait on. It is a process that stays up.

That moves the bottleneck. When an agent answers once and forgets, capability is the whole game. When it runs continuously - on a schedule, across restarts, for days - the hard part is no longer whether it can reason, but whether it stays alive, resumes where it left off, and can be watched and stopped. Uptime, recovery, and supervision become the scarce resources - systems problems, not model problems.

Back in PR#29 we argued the missing layer was where agents run safely. This issue is one step past that: not where they run, but whether they keep running. That is the lens for this issue: the open substrate for always-on agents - the operating system, the control surface, the durable runtimes, and the survival layer underneath.

🐺 OpenFang (GitHub) 17.8k ☆ - An agent operating system built to run 24/7

The Scoop: OpenFang is a Rust “agent operating system” that runs autonomous agents on schedules around the clock rather than waiting to be prompted, compiled to a single binary. Built and maintained by Jaber, founder of RightNow, under MIT.

Why It’s a Big Deal

• It treats the agent as a long-lived process, not a chat session - scheduled autonomous work is the default, the always-on shift the rest of the stack is racing to support.

• Its bundled “Hands” - seven capability packages that run on a schedule without prompting - reframe an agent as something that works in the background, where peers still wait for a human turn.

• Shipping as a single binary you install and leave on pushes agent tooling toward the operating-system tradition, not the notebook-and-API one it grew out of.

Under the Hood

• 14 Rust crates compiling to one binary, with a WASM dual-metered sandbox (fuel plus epoch interruption) for tool code and 16 security layers, including a Merkle hash-chain audit trail and Ed25519-signed manifests.

• 40 channel adapters (Telegram, Discord, Slack, Matrix and more) and 27 LLM providers behind an OpenAI-compatible endpoint with routing, fallback, and cost tracking.

• SQLite persistence with vector embeddings for memory, a Tauri 2.0 desktop app, and an OFP peer-to-peer protocol with HMAC-SHA256 auth across 140+ endpoints.

OpenFang is not just an agent framework - it is an operating system for agents that never log off.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🎛️ CopilotKit (GitHub) 35.1k ☆ - The human control surface for a running agent

The Scoop: CopilotKit is a frontend stack for agent-native apps - chat UI, generative UI, shared state, and human-in-the-loop - for React and Angular, and the team behind the AG-UI protocol. MIT, primarily TypeScript.

Why It’s a Big Deal

• An always-on agent still needs a window a human can see through and reach into, and CopilotKit is becoming the standard one.

• Generative UI lets a running agent render and update its own interface, so supervision scales with the agent instead of being hand-built per app.

• Shared state plus human-in-the-loop lets an autonomous agent pause for approval mid-run - the control primitive you need once agents stop waiting for you.

Under the Hood

• Built on the AG-UI (Agent-User Interaction) protocol, adopted across LangChain, AWS, Microsoft, Mastra, and PydanticAI.

• A useAgent hook sits directly on AG-UI, with first-party integrations for LangGraph and CrewAI.

• A pnpm and Nx monorepo shipping React core packages alongside a Python SDK.

CopilotKit shows that an always-on agent still needs a human-shaped window - and that window is turning into open infrastructure.

🧙 Mastra (GitHub) 25.1k ☆ - Durable, resumable workflows for long-running agents

The Scoop: Mastra is a TypeScript framework for building agents and AI apps from prototype to production, from the team behind Gatsby and a YC W25 company. Core is Apache 2.0, with source-available enterprise modules.

Why It’s a Big Deal

• Its human-in-the-loop suspend and resume is backed by storage, so a workflow can pause indefinitely and pick up where it left off - the core move an always-on agent depends on.

• A graph-based workflow engine with explicit control flow turns open-ended agent loops into durable, inspectable processes you can operate.

• Built-in evals and observability treat reliability as part of the framework, not a bolt-on once the agent ships.

Under the Hood

• Model routing across 40+ providers behind one interface, plus working and semantic memory that survives a session.

• Authors and exposes MCP servers, and integrates with the Vercel AI SDK UI and CopilotKit for front-ends.

• Deploys into React, Next.js, or Node, or as a standalone server, with control flow as .then(), .branch(), and .parallel().

Mastra is a sign that durable, resumable execution is moving from a feature into the default shape of an agent framework.

⚡ VoltAgent (GitHub) 9.6k ☆ - An observability-first runtime built for uptime

The Scoop: VoltAgent pairs an open-source TypeScript agent framework with the VoltOps console for tracing, evals, and deployment, so a long-running agent can be watched and operated. MIT.

Why It’s a Big Deal

• Observability-first is the right instinct for always-on - run an agent for days and you need traces and dashboards more than another demo, and VoltAgent ships them built in.

• Declarative workflows with suspend and resume support human approval mid-run, the same continuity primitive this issue keeps circling.

• Self-hosted scheduling and resumable streaming keep the agent working while you are away and surviving a reconnect.

Under the Hood

• Built on Vercel AI SDK model adapters, so providers swap by config rather than rewrites.

• A Zod-typed tool registry with lifecycle hooks and cancellation, plus MCP server support and a docs server for coding assistants.

• Pluggable memory adapters, a Pino logger, and a Hono-based server.

VoltAgent is what an agent runtime looks like when uptime, not capability, is the hard part.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🧪 EvalView (GitHub) 114 ☆ - A behavior regression gate for agents, the Playwright for AI agents

The Scoop: EvalView snapshots an agent’s tool calls and outputs, diffs them against a golden baseline, and fails the build when behavior silently drifts - including when a model or runtime quietly changes underneath you. Apache 2.0, by hidai25, aimed at solo devs and small teams keeping a long-running agent honest.

Get started: pip install evalview then evalview init and evalview snapshot

♻️ Restate (GitHub) 4k ☆ - Durable execution so always-on survives a crash

The Scoop: Restate is a Rust durable-execution platform that guarantees code runs to completion - failures retry and recover partial progress instead of re-running finished steps - with exactly-once messaging, consistent per-entity state, and a stated focus on durable AI agents. Self-hostable, with SDKs for TypeScript, Java, Python, Go, and Rust.

Get started: brew install restatedev/tap/restate-server or npx @restatedev/restate-server

🪢 sayiir (GitHub) 61 ☆ - An embeddable durable workflow engine

The Scoop: sayiir is a lightweight, embeddable durable workflow engine with a Rust core and Python and Node bindings, using checkpoint-based recovery rather than deterministic replay - so workflow code can call any library or API and still resume from its last checkpoint after a crash. MIT, by Yacine, positioned as a small alternative to Temporal and Restate you install rather than deploy.

Get started: pip install sayiir (or npm install sayiir / cargo add sayiir-core)

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

This week JetBrains open-sourced Mellum2 under Apache 2.0 — a 12B mixture-of-experts model with only 2.5B parameters active per token, trained from scratch on code and natural language. The pitch is not another leaderboard run. JetBrains is explicit that Mellum2 is a focal model: a fast, specialized component for routing, summarization, intermediate reasoning, and quick sub-agents — exactly the high-frequency, latency-sensitive steps you’d be crazy to spend a frontier model on. Their stated thesis is that the future belongs to coordinated systems, not single models, and that practical AI products need focal models sitting next to the big ones.

That confirms the shift Repository Radar has been tracking all year: capability is no longer the scarce resource. Open weights are everywhere, focal models cut inference time in half, and the “one agent, one job” pattern is winning. What’s scarce now is context — getting the right, compressed, well-structured information in front of whatever model you’re running. When the model layer commoditizes, value migrates up to the layer that decides what the model sees, produces, and remembers.

That’s the lens for this issue: nearly every pick lives in the context layer — comprehension, compression, taste, team-generation, memory. It’s the connective tissue that makes a cheap focal model behave like an expensive one.

🗺️ Understand-Anything (GitHub) 50k ☆ - The open comprehension substrate for the focal-model era

The Scoop: Understand-Anything is a multi-agent pipeline (and Claude Code plugin) that analyzes any project — or a Karpathy-pattern LLM wiki — and builds a knowledge graph of every file, function, class, and dependency, then renders it as an interactive dashboard you can pan, search, and ask questions about. Plugin-native across Claude Code, Codex, Cursor, Copilot, Gemini CLI, and a dozen more agents. MIT, by Yuxiang Lin.

Why It’s a Big Deal

• A fast model is only as good as the context routed to it, and a navigable graph is how you build that context cheaply — Understand-Anything is the comprehension layer that the focal-model thesis depends on.

• The graph ships as plain JSON you commit once, so teammates and agents skip the whole indexing pipeline — onboarding, PR review, and docs-as-code come along for free.

• It crosses the human/agent boundary on purpose: the same graph that gives a new hire a guided tour gives an agent diff-impact analysis and semantic search.

Under the Hood

• Five-to-seven specialized agents (project-scanner, file-analyzer, architecture-analyzer, tour-builder, graph-reviewer, plus domain and wiki analyzers) run in parallel and re-run incrementally on changed files only.

• Output is layer-colored, searchable, and persona-adaptive, with a force-directed knowledge-base mode and community clustering for wikis.

• TypeScript core, one-line install or /plugin marketplace add, and a post-commit hook that keeps the graph fresh as you code.

Understand-Anything is what “context engineering” looks like when you hand both the human and the model the exact same map.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🎨 taste-skill (GitHub) 31.6k ☆ - Anti-slop design skills that fix what AI-built UIs get wrong

The Scoop: taste-skill is a set of portable Agent Skills (SKILL.md files) that upgrade AI-generated frontends — stronger layout, typography, motion, and spacing instead of the generic boilerplate look. Framework-agnostic, works with Codex, Cursor, and Claude Code, and installs with a single npx skills add. MIT, by Leonxlnx.

Why It’s a Big Deal

• As code generation gets commoditized, taste becomes the differentiator — and taste-skill encodes it as a reusable instruction file rather than a one-off prompt.

• Three tunable dials (variance, motion, density) plus opinionated variants — minimalist, brutalist, soft, redesign — let you set a visual direction without hand-holding the model.

• It bundles image-generation skills for reference boards, so the design language is locked before a line of code gets written.

Under the Hood

• Skills are discovered from the repo’s skills/ folder by the npx skills add CLI; you can also paste a SKILL.md straight into a chat or drop it into a project.

• The v2 rewrite infers the brief, maps a design system, and runs a strict pre-flight check before generating.

• Pure portable skill files — no runtime, no bundler, no lock-in.

taste-skill is a bet that the scarce thing in AI frontends isn’t code — it’s judgment, and judgment now ships as a file.

🕸️ codegraph (GitHub) 37.8 ☆ - Pre-indexed code graph that cuts Claude Code’s tool calls ~90%

The Scoop: codegraph is an MCP server that hands Claude Code’s Explore agents a pre-indexed knowledge graph — symbols, call graphs, structure — so they query the graph instead of grepping the filesystem. 100% local (SQLite + tree-sitter), 19+ languages, zero data leaving your machine. MIT, by Colby McHenry.

Why It’s a Big Deal

• The context-efficiency layer made literal: the author’s benchmarks across six real codebases report roughly 92% fewer tool calls and 71% faster exploration.

• It pairs cleanly with the focal-model thesis — fewer tokens burned on discovery means a smaller, cheaper model can answer the same architecture question.

• A native file watcher auto-syncs the graph as you code, so it stays current with zero configuration.

Under the Hood

• tree-sitter parses source into ASTs that land in SQLite with FTS5; a resolution pass links calls to definitions, imports to files, and class inheritance.

• It exposes search / callers / callees / impact / context as MCP tools, plus a library API for your own pipelines.

• codegraph affected traces import dependencies to pick exactly which test files a diff touches — drop it into CI or a pre-commit hook.

Same question, a fraction of the tokens — codegraph is what “understanding” costs when you precompute it.

🪽 hermes-webui (GitHub) 12.4k ☆ - A web and mobile front door for an always-on, remembering agent

The Scoop: hermes-webui is a lightweight web app — Python plus vanilla JS, no build step or framework — for Nous Research’s Hermes Agent, with near 1:1 CLI parity, persistent memory, self-hosted scheduling, and access from 10+ messaging platforms. MIT, by Nathan Esquenazi.

Why It’s a Big Deal

• The persistent-runtime layer: most tools reset every session, while Hermes retains a user profile, agent notes, and self-written skills, so it gets more capable the longer it runs.

• Provider-agnostic and fully self-hosted — your memory, your hardware — and it can spawn Claude Code or Codex for heavy coding and fold the results back into its own memory.

• It’s reachable from your phone over Tailscale or an SSH tunnel, turning a server-side agent into a genuine daily driver.

Under the Hood

• Three-panel UI (sessions / chat / workspace) with SSE streaming, inline tool-call cards, and a context-usage ring; runs the agent in-process or in separate containers.

• Self-hosted cron jobs fire while you’re offline and deliver results to Telegram, Discord, Slack, Signal, email, and more.

• 137 contributors with code in a release tag and 430+ releases — a community project shipping at sprint cadence.

hermes-webui is the memory-and-presence layer: the part of the stack that remembers who you are after the model forgets.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🎙️ dograh (GitHub) 4.1 ☆ - Open-source voice-agent platform, the Vapi alternative

The Scoop: dograh is a drag-and-drop builder that takes you from zero to a working voice bot in under two minutes — self-hostable with no vendor lock-in, bring-your-own LLM/TTS/STT, built-in AI testing personas (LoopTalk), and telephony via Twilio, Vonage, and friends. Built on pipecat, maintained by a YC-alumni team, BSD-2-Clause.

Get started: curl -o docker-compose.yaml https://raw.githubusercontent.com/dograh-hq/dograh/main/docker-compose.yaml && docker compose up

🏭 harness (GitHub) 5.5k ☆ - A factory that builds whole agent teams from one sentence

The Scoop: harness is a Claude Code meta-skill — say “build a harness for this project” and it turns a domain description into an agent team plus the skills they use, picked from six team patterns (pipeline, fan-out/fan-in, expert pool, producer-reviewer, supervisor, hierarchical delegation). Apache 2.0, by Minho Hwang; an author-measured A/B run reports +60% output quality (n=15, third-party replications pending).

Get started: /plugin marketplace add revfactory/harness then /plugin install harness@harness

🗜️ headroom (GitHub) 5.7k ☆ - Context compression before tokens ever reach the model

The Scoop: headroom compresses everything an agent reads — tool outputs, logs, RAG chunks, files, and history — for 60-95% fewer tokens with the same answers, as a library, a drop-in proxy, or an MCP server. Local-first and reversible (originals stay retrievable on demand), with cross-agent memory and a headroom learn mode that mines failed sessions into CLAUDE.md fixes. Apache 2.0, by Tejas Chopra; integrates with LiteLLM (our PR #34 pick), LangChain, the Vercel AI SDK, and more.

Get started: pip install "headroom-ai[all]" then headroom wrap claude

Repository Radar is brought to you by Alexander, a Tech Investor at Keen, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Recently Palo Alto Networks announced it will acquire Portkey, the AI Gateway company, to anchor the routing and security control plane of its Prisma AIRS product. Portkey was already moving trillions of tokens per month for enterprise customers and had open-sourced its production gateway under MIT. Palo Alto did not buy a startup so much as the standard switch between agents and the model layer.

That matters because it confirms a pattern: the agent stack is now stratifying fast enough that each horizontal layer is becoming an acquisition target on its own terms. Gateway, memory, filesystem, observability - none of these were standalone categories two years ago. Today they are well-defined enough that incumbents in adjacent markets (security, networking, data) are willing to pay to own them. The question Repository Radar keeps coming back to: when an upstream commercializes, which open-source primitive becomes the substrate everyone else builds on?

That is the lens for this issue: in each layer the agent stack is forking into commercial-and-locked-in vs. open-and-substrate, and most of our picks sit in the second category - projects that stay vendor-neutral while the layer matures around them.

🛣️ LiteLLM (GitHub) 46k ☆ - The OSS AI gateway that stays independent post-Portkey

The Scoop: LiteLLM is a Python SDK and self-hostable proxy server that exposes 100+ LLM providers - OpenAI, Anthropic, Bedrock, Azure, VertexAI, Cohere, NVIDIA NIM, vLLM, and more - behind a single OpenAI-compatible API. Maintained by Y-Combinator-backed BerriAI under MIT.

Why It’s a Big Deal

• With Portkey heading into Palo Alto's Prisma AIRS, LiteLLM is the most mature OSS analog that stays self-hostable and provider-agnostic.

• It treats the AI gateway as a primitive, not a product - virtual keys, per-team spend ledgers, and provider fallback shipped as a library you run yourself.

• Battle-tested at over 10B tokens and shipping roughly 394 pull requests a month, it is the gateway layer small teams and enterprise alike keep reaching for.

Under the Hood

• Dual-mode: drop-in Python library (litellm.completion(...)) or standalone FastAPI proxy server with admin UI.

• Per-provider adapter pattern translates OpenAI-format requests and streams to native provider SDKs, with first-class guardrails, retries, and load balancing.

• Multi-tenant from the start - virtual API keys, team and user spend tracking, per-key model allow-lists.

LiteLLM is not just an OpenAI shim - it is the gateway substrate that survives when the gateway companies get bought.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

💹 AI-Trader (GitHub) 16.2k ☆ - Multi-agent trading arena built natively on MCP

The Scoop: AI-Trader from HKU’s Data Intelligence Lab is a platform where LLM agents (GPT, Claude, DeepSeek, Qwen, Gemini) autonomously research, debate, and execute trades across stocks, crypto, forex, options, and futures. Live competitions on Nasdaq 100, A-shares, and major cryptos run head-to-head.

Why It’s a Big Deal

• Trading is the cleanest stress test for agent-native systems - live data, real consequences, direct comparison across models in the same arena.

• Built on the Model Context Protocol from day one: every trading action is a typed MCP tool call, not a custom integration.

• Pairs naturally with the gateway and memory layers in this issue - the verticals are only usable because the horizontals work.

Under the Hood

• FastAPI backend with a React frontend; full OpenAPI spec under docs/api.

• LangChain + langchain-mcp-adapters + fastmcp toolchain handles the MCP wiring; tushare provides Chinese market data alongside US feeds.

• Agents can copy each other’s positions and post discussion signals, turning the platform into a quasi-public ledger of agent intent.

AI-Trader makes the case that vertical agent arenas, not single-bot products, are the natural shape of agent-native finance.

🦀 DeepSeek-TUI (GitHub) 29k ☆ - Coding agent built natively around DeepSeek V4

The Scoop: DeepSeek-TUI is a Rust terminal coding agent purpose-built for DeepSeek V4, with reading, editing, command execution, web search, and orchestrated sub-agents. From near-zero to 29k stars in two weeks - the fastest-trending repo in this window.

Why It’s a Big Deal

• The first credible coding-agent CLI wired natively to DeepSeek V4 rather than retrofitted through OpenAI-compatible adapters.

• Surfaces DeepSeek’s native thinking blocks directly in the transcript, making the reasoning trace part of the workflow rather than a hidden side-effect.

• Ships the parallel sub-agent primitive (up to 16 V4-Flash workers per call) as a first-class tool, not a side feature.

Under the Hood

• Dual-binary architecture: deepseek (dispatcher CLI) launches deepseek-tui (ratatui + async engine + tool loop).

• Three operating modes - Plan (read-only), Agent (per-tool approval), YOLO (auto-execute) - mirroring the now-standard Claude Code permission model.

• Typed tool registry covers shell, file ops, git, web, MCP, sub-agents, and RLM; speaks OpenAI-compatible streaming protocol.

DeepSeek-TUI is what happens when the open-model layer is strong enough that coding agents start being designed around it rather than against the closed labs.

🥧 pi-mono (GitHub) 43.6k ☆ - Anti-framework AI agent toolkit from the libGDX creator

The Scoop: pi-mono is Mario Zechner’s TypeScript monorepo containing pi, a minimal coding-agent CLI with exactly four tools (read, write, edit, bash), plus the reusable LLM, TUI, and web UI primitives behind it. The deliberate anti-framework counterweight to Claude Code’s growing surface area.

Why It’s a Big Deal

• Four tools, no plan mode, no sub-agents in core, sub-1000-token system prompt - a credible bet that less scaffolding produces better agent behavior.

• Bundles a unified LLM client, terminal UI library, web UI components, Slack bot template, and vLLM deployment helpers - one repo covering several horizontal layers of the agent stack.

• Extension through “Pi Packages” distributed as npm or git keeps the core surface lean while letting the ecosystem grow around it.

Under the Hood

• npm workspaces monorepo with lockstep versioning; packages migrating to @earendil-works/* scope.

• Layered stack: coding-agent CLI → agent runtime → unified LLM API → TUI and web rendering libs.

• Built on the assumption that the model is smart enough to do most things without framework hand-holding, and the harness should stay out of the way.

pi-mono is a strong example of OSS pushing back on the agent-framework arms race - by shipping the smallest possible harness and the primitives to extend it.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🧠 agentmemory (GitHub) 9k ☆ - Local-first persistent memory for coding agents

The Scoop: agentmemory captures tool-use events from coding agents (Claude Code, Cursor, Codex CLI, Gemini CLI, Hermes, OpenClaw, pi, OpenCode and others) via hooks, MCP, or REST, then LLM-compresses, indexes, and serves them back into future sessions. All data local, sub-20ms retrieval.

Get started: npm install -g @agentmemory/agentmemory

🗂️ mirage (GitHub) 1.9k ☆ - Unified virtual filesystem for AI agents

The Scoop: mirage from Strukto AI mounts S3, Google Drive, GitHub, Notion, Gmail, Slack, Redis, and Postgres side-by-side under one POSIX-shaped root, so agents can ls, cat, grep, find, and pipe across services using their existing bash tool.

Get started: uv add mirage-ai (Python) or npm install @struktoai/mirage-node (TypeScript)

🪞 openhuman (GitHub) 7.9k ☆ - Private local-first desktop AI assistant

The Scoop: openhuman is a Rust + Tauri desktop assistant that ingests email, chat, and documents into a local Memory Tree, runs an ambient background thinking loop, and renders as an on-screen mascot - it can even join Google Meets. Built after the maintainer’s failed attempt to set up an open-source AI agent for his father.

Get started: curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash

Repository Radar is brought to you by Alexander, a Tech Investor, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

This week’s headline is Warp going open source, and it is not just a license change. Warp is open-sourcing its agentic development environment under AGPL, with a contribution model where agents do the heavy lifting and the community supervises. OpenAI is the founding sponsor, and contributions flow through Warp’s cloud agent orchestration platform Oz.

That matters because it reframes the bottleneck of open source. The constraint has rarely been writing code - it has been spec’ing, reviewing, and verifying. If agents handle implementation while humans shape direction and validate output, the limits of small core teams largely dissolve. Pace stops being capped by headcount.

This also signals something bigger: closed-source agentic dev environments now have a credible open alternative, with public roadmaps and open issue tracking. The future of how software gets built is being decided in the open, not behind a paywall.

That is the lens for this issue: open source is no longer just a license model - it is becoming the substrate for agent-native software development.

🧰 Warp (GitHub) 54.9k ☆ - Open source agentic development environment built with agents

The Scoop: Warp is now open source under AGPL, with its full agentic development environment available on GitHub. Contributions are powered by Oz, Warp’s cloud agent orchestration platform, with OpenAI as the founding sponsor of the new repository.

Why It’s a Big Deal

• Introduces a new contribution model where agents handle implementation and humans focus on direction and verification.

• Provides the first credible full-featured open alternative to closed-source agentic dev environments.

• Shifts product development to public issues and an open roadmap, putting community input at the center.

Under the Hood

• Source available at github.com/warpdotdev/warp under AGPL, with contribution flow documented in CONTRIBUTING.md.

• Oz orchestrates agents with structured rules, context, and verification loops to keep generated code production-grade.

• Adds support for open-source models including Kimi, MiniMax, and Qwen, plus a new “auto (open)” model router.

Warp’s open-sourcing is not just a license change - it is a blueprint for how agent-built software might scale.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🌊 Ruflo (GitHub) 43.4k ☆ - Multi-agent orchestration for Claude Code

The Scoop: Ruflo (formerly Claude Flow) turns Claude Code into a coordinated multi-agent system, with 100+ specialized agents, swarm coordination, and federated communication across machines.

Why It’s a Big Deal

• Pushes single-agent coding tools into swarm-based execution with shared memory and consensus.

• Adds zero-trust federation so agents on different machines and orgs can collaborate without leaking data.

• Treats agent learning as core infrastructure, with self-improving patterns persisted across sessions.

Under the Hood

• Built around an MCP server with hooks, 32 native Claude Code plugins, and 21 npm plugins.

• Vector memory using HNSW-indexed AgentDB with sub-millisecond retrieval.

• Multi-provider support across Claude, GPT, Gemini, Cohere, and local models via Ollama.

Ruflo shows what happens when single-agent IDEs grow into managed swarms with their own infrastructure.

🧠 Context Mode (GitHub) 13k ☆ - Virtualization layer for AI agent context

The Scoop: Context Mode is an MCP server that solves the context window problem, intercepting tool calls so raw data never enters the conversation, while persisting session state across compactions.

Why It’s a Big Deal

• Treats context as a system resource that needs virtualization, not just a prompt to manage.

• Extends typical agent sessions from around 30 minutes to multiple hours by cutting context use up to 98%.

• Works across Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI as a portable layer.

Under the Hood

• Sandbox tools run code in isolated subprocesses with only stdout entering context.

• SQLite FTS5 with BM25 ranking and three-layer fuzzy search powers on-demand retrieval.

• Hooks intercept Bash, Read, and WebFetch calls before execution to enforce sandbox routing.

Context Mode highlights how core agent infrastructure is moving below the application layer.

✍️ DocuSeal (GitHub) 13.9k ☆ - Open source alternative to DocuSign

The Scoop: DocuSeal is an open source platform for creating, filling, and signing PDF documents online, with a WYSIWYG form builder, mobile-optimized signing, and self-hostable deployment.

Why It’s a Big Deal

• Continues the long pattern of open source unbundling closed-source SaaS in enterprise document workflows.

• Provides full self-hosting and white-label options, addressing data sovereignty and compliance concerns.

• Ships embedded SDKs for React, Vue, and Angular, making integration into existing apps straightforward.

Under the Hood

• Built on Ruby on Rails with a Vue.js frontend and Tailwind CSS.

• Supports SQLite, PostgreSQL, and MySQL with storage on disk, AWS S3, Google Storage, or Azure.

• Ships Docker and docker-compose setups with automatic SSL certificates via Caddy.

DocuSeal is a reminder that the older open-source tradition of unbundling SaaS continues in parallel to the agent wave.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

⚖️ Mike (GitHub) 2.2k ☆ - Open source AI legal platform

The Scoop: Mike is an open source AI legal platform with a Next.js frontend and Express backend, built on Supabase with document processing and multi-model provider support.

Get started: clone the repo, run npm install in backend and frontend, then npm run dev --prefix backend.

🛠️ Craft Agents (GitHub) 5.8k ☆ - Document-centric desktop app for agents

The Scoop: Craft Agents is an open source desktop GUI for working with agents, built on the Claude Agent SDK with multi-session inbox, MCP and REST API integration, and a non-CLI workflow.

Get started: install via curl -fsSL https://agents.craft.do/install-app.sh | bash on macOS or Linux.

🥥 CocoIndex (GitHub) 8.3k ☆ - Data transformation framework for AI

The Scoop: CocoIndex is a Rust-powered Python framework for AI data transformation, with incremental processing, data lineage, and out-of-box vector and knowledge graph indexing.

Get started: install via pip install -U cocoindex and follow the quickstart guide at cocoindex.io/docs.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

In this issue, we are starting from a broader system shift rather than a single launch. AI is no longer just helping developers write code. It is increasingly interacting directly with software systems themselves - classifying inputs, executing workflows, and probing for weaknesses in continuous loops.

That matters because it changes where the bottlenecks sit. Many processes that used to be periodic and human-driven are becoming always-on. Systems can now be inspected, tested, and iterated on far more frequently than traditional workflows allowed.

Security is where this becomes most visible. AI systems are now capable of discovering vulnerabilities at a pace that exceeds traditional remediation cycles. The limiting factor is no longer finding issues, but fixing them fast enough. As a result, security shifts from periodic audits to continuous system inspection.

That is the lens for this issue: software is now continuously processed by AI systems across the entire lifecycle - and security is becoming just another automated loop.

🧰 Nuclei (GitHub) 27.9k ☆ - Programmable vulnerability scanning for continuous security workflows

The Scoop: Nuclei is a high-performance open-source vulnerability scanner built around a simple YAML-based templating system. Instead of relying on fixed scanning logic, it allows users to define custom detection workflows that simulate real-world attack scenarios across applications, APIs, and infrastructure.

Why It’s a Big Deal

• It turns vulnerability scanning into a programmable system, where detection logic can be defined, versioned, and shared across teams.

• The open template ecosystem allows vulnerability discovery to scale through community contributions and increasingly AI-generated logic.

• By integrating into CI/CD pipelines, it shifts security from periodic checks to continuous, always-on inspection.

Under the Hood

• Uses a YAML-based DSL to define requests, matching logic, and validation steps for precise vulnerability detection.

• Maintains a large, community-driven template library covering CVEs, misconfigurations, and common attack vectors.

• Optimized for high-speed parallel execution across multiple protocols including HTTP, DNS, TCP, and cloud services.

Nuclei is not just another vulnerability scanner - it is an execution layer for continuously testing software systems in an AI-driven security loop.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🧠 Magika (GitHub) 13.4k ☆ - AI-powered file classification at scale

The Scoop: Magika is an AI-based file type detection system trained on around 100m samples across 200+ content types, designed to classify files quickly and accurately across large-scale systems.

Why It’s a Big Deal

• Replaces rule-based detection with learned classification, improving reliability across diverse file formats.

• Already deployed at massive scale, showing AI classification is now core infrastructure.

• Forms a foundational layer for AI systems to continuously interpret raw data.

Under the Hood

• Lightweight model with millisecond inference on CPU.

• Uses partial file content for near-constant inference time.

• Available across multiple runtimes including Python, Rust, and JavaScript.

Magika shows how even basic system primitives are being redefined as AI-driven processes.

🎙️ Voicebox (GitHub) 17.9k ☆ - Local-first voice generation platform

The Scoop: Voicebox is an open-source voice synthesis studio that enables voice cloning, speech generation, and audio processing locally, supporting multiple TTS engines and languages.

Why It’s a Big Deal

• Brings high-quality voice generation fully on-device, reducing reliance on APIs.

• Combines multiple open models into a modular production system.

• Expands AI workflows into multimodal creation beyond text and code.

Under the Hood

• Built with Tauri, FastAPI, and multiple inference backends.

• Supports multiple TTS engines with different performance profiles.

• Includes timeline editing, effects processing, and API access.

Voicebox highlights how multimodal AI is becoming local and composable.

⚡ RTK (GitHub) 27k ☆ - Compression layer for AI-native workflows

The Scoop: RTK is a CLI proxy that reduces LLM token usage by filtering and compressing command outputs before they reach the model.

Why It’s a Big Deal

• Makes token usage a first-class optimization layer in AI workflows.

• Sits between tools and models as infrastructure for efficiency.

• Signals a shift toward optimizing AI interaction, not just model performance.

Under the Hood

• Applies filtering, grouping, and deduplication to command outputs.

• Uses hooks to transparently rewrite commands.

• Provides analytics on token usage and savings.

RTK shows how the interface between tools and models is becoming infrastructure.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🔥 CodeBurn (GitHub) 1.4k ☆ - Token and cost observability for AI coding

The Scoop: CodeBurn is a terminal dashboard that tracks token usage, cost, and performance across AI coding sessions by reading local transcripts.

Get started: install via npm install -g codeburn or run npx codeburn.

📈 Vibe-Trading (GitHub) 1.9k ☆ - Multi-agent trading and backtesting system

The Scoop: Vibe-Trading turns natural language inputs into executable trading strategies, backtests, and portfolio analysis across markets.

Get started: install via pip install vibe-trading-ai and launch the CLI.

🤖 Open Agents (GitHub) 2.2k ☆ - Reference architecture for cloud agents

The Scoop: Open Agents is an open-source template for building persistent coding agents with workflow execution and sandboxed environments.

Get started: fork the repo and deploy via Vercel.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

PR #31 arrives at the intersection of two trends that the repos in this issue collectively put in sharp relief.

The first trend is what Andrej Karpathy declared passé in February 2026: vibe coding. The term he coined just a year earlier — building with AI by fully giving in to prompts and intuition — has already been superseded in professional discourse by what he now calls agentic engineering: the discipline of orchestrating teams of AI agents that plan, write, test, and ship code under structured human oversight. The shift is not just semantic. Fortune ran a piece this month on the rise of the “Supervisor Class” — developers whose primary value is no longer writing code line by line but orchestrating parallel agent workflows. The emerging job description is Agent Orchestrator, and it is already appearing in real hiring posts. Practitioners running three or four Claude Code, Codex, and Gemini CLI instances in parallel — each in its own git worktree — have given this pattern its own name: agentmaxxing. Tools that help developers manage, coordinate, and review that kind of parallel agent output are now the real infrastructure gap.

The second trend is that agents are no longer just writing code. They are running experiments, generating research papers, and simulating entire social systems. MiroFish — built in ten days by a 20-year-old undergraduate in China — secured $4.1 million in seed funding from Shanda Group founder Chen Tianqiao within 24 hours of a viral demo, after hitting the top trending spot on GitHub. The project constructs parallel digital worlds populated by thousands of autonomous agents, each with independent personalities, long-term memory, and behavioral logic, then runs social emergence simulations to forecast real-world outcomes. That is a different category of agent use than code generation. It is agents as scientific and analytical infrastructure — predicting public opinion dynamics, financial market reactions, and political scenarios before they happen.

What connects these two trends is a shared architectural bet: that the unit of AI work is no longer the single model call, but a coordinated system of agents operating in parallel on isolated workstreams, integrated by a human (or another agent) acting as orchestrator.

🐟 MiroFish (GitHub) 50.4k ☆ — Multi-agent swarm intelligence engine for predicting real-world outcomes

The Scoop: MiroFish is a next-generation AI prediction engine that ingests seed materials — breaking news, financial signals, policy drafts — and builds a high-fidelity parallel digital world. Thousands of agents with independent personalities, long-term memory, and behavioral logic then freely interact and socially evolve inside that simulated world. You can inject variables from a “God’s-eye view” and watch the trajectories unfold. The result is a detailed prediction report, plus a deeply interactive sandbox you can keep exploring. The project has received strategic incubation from Shanda Group and officially recommends Alibaba’s Qwen-plus as its default LLM backbone.

Why It’s a Big Deal

It is one of the most compelling live examples of multi-agent simulation moving from research demos into a usable, deployable product. Rather than LLMs generating text about predictions, MiroFish runs actual social emergence: individual interactions aggregating into collective behavior that neither the creator nor the user directly specified. The fact that it recommends Qwen-plus as its default backbone also ties neatly into the broader trend of Chinese open models becoming functional infrastructure for downstream products — the same platform gravity story playing out in practice.

It also covers a genuinely wide range of prediction use cases that have real economic stakes: financial forecasting, political public-opinion analysis, and more creative or narrative-driven scenarios (one demo re-simulates the lost ending of Dream of the Red Chamber). That breadth, and the fact that it runs locally with Docker, suggests it is trying to be infrastructure rather than just a demo.

Under the Hood

The workflow is a five-stage pipeline: graph building via GraphRAG and persona injection, environment setup including entity extraction, full parallel simulation, a ReportAgent phase with rich toolset access, and a deep interaction layer where you can chat with any simulated agent or the report itself. The backend is Python and the frontend Vue, with both Docker and source deployment supported. Zep Cloud handles the long-term memory layer for individual agents. A live demo environment is available at the public mirofish demo page.

MiroFish is a strong early example of what happens when swarm intelligence leaves the academic paper and tries to become a self-hosted product with real inputs, real outputs, and a UI non-researchers can actually use.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🎭 agency-agents (GitHub) 72.5k ☆ — A complete library of production-ready AI agent personalities for coding environments

The Scoop: agency-agents is a growing collection of 144+ meticulously crafted AI agent personalities organized into 12 divisions — engineering, design, marketing, sales, product, project management, testing, support, game development, spatial computing, paid media, and academic. Born from a Reddit thread, each agent is built around a strong personality, explicit deliverables, a step-by-step workflow, and measurable success metrics. The repo ships conversion and install scripts that deploy agents across ten tools: Claude Code, GitHub Copilot, Cursor, Aider, Windsurf, Gemini CLI, Antigravity, OpenCode, OpenClaw, and Qwen Code.

Why It’s a Big Deal

It treats agent prompts as software artifacts with real structure, rather than one-off strings. Each agent has identity, process, deliverables, and success metrics. That framing matters: it is the difference between a prompt you copy and a system component you install, version, and improve. The multi-tool install scripts are particularly notable — they abstract the same agent personality across the entire emerging agentic coding ecosystem in a single ./scripts/install.sh call. The breadth of covered roles, including game development divisions spanning Unity, Unreal, Godot, and Blender, suggests this is aiming at something closer to a professional operating system for agent work than a starter prompt pack.

Under the Hood

Agents live as .md files organized by division and role. The conversion layer (convert.sh) transforms them into the native format of each supported tool — .mdc for Cursor, CONVENTIONS.md for Aider, per-agent SKILL.md files for Gemini CLI extensions, and so on. A parallel flag enables faster multi-core installs. Community translations have already appeared, with Chinese-language forks covering Baidu, WeChat, Xiaohongshu, and Bilibili-specific agents that do not exist in the main repo.

agency-agents is what shared agent infrastructure looks like when you build for portability first.

🖥️ openscreen (GitHub) 23.3k ☆ — Free, open-source screen recorder for polished product demos

The Scoop: openscreen is an Electron-based desktop app that lets anyone create professional-looking product demos and walkthroughs without paying for Screen Studio. It covers the core features most users actually need: whole-screen or window recording, automatic and manual zoom with customizable depth, microphone and system audio capture, motion blur for smooth pan and zoom, annotations including text and arrows, crop, trim, speed control, and export in multiple aspect ratios and resolutions. MIT licensed, no watermarks, free for commercial use.

Why It’s a Big Deal

The demo-recording space has largely been dominated by a small number of polished but expensive tools. openscreen is a direct signal that developers are no longer willing to pay subscription rates for capabilities that can be replicated in open source. The fact that it reached this star count while still officially in beta, and while the creator explicitly describes themselves as new to open source, suggests there is real pent-up demand for a no-gotchas alternative in this category.

Under the Hood

Built with Electron, React, TypeScript, Vite, PixiJS for visual rendering, and dnd-timeline for segment management. System audio capture is handled via Electron’s desktopCapturer and has expected platform-specific constraints: macOS 13+ required, Linux needs PipeWire. Available as a pre-built installer for macOS (with Gatekeeper bypass instructions), Windows, and Linux AppImage. The project maintains a public roadmap and welcomes contributions.

☤ hermes-agent (GitHub) 27k ☆ — Self-improving, platform-agnostic AI agent with a built-in learning loop

The Scoop: hermes-agent is Nous Research’s open-source AI agent built around a closed learning loop: it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations via FTS5 with LLM summarization, and builds a deepening user model across sessions using Honcho dialectic user modeling. It runs on any provider — Nous Portal, OpenRouter’s 200+ model catalog, z.ai, Kimi/Moonshot, MiniMax, OpenAI, or any custom endpoint — and switches with a single hermes model command. It connects to Telegram, Discord, Slack, WhatsApp, Signal, and CLI from a single gateway process, runs scheduled automations via a built-in cron scheduler, and supports six terminal backends including serverless options like Daytona and Modal that hibernate when idle.

Why It’s a Big Deal

It is one of the few openly available agents that treats memory and skill accumulation as first-class infrastructure rather than afterthoughts bolted onto a chat loop. The learning loop is architecturally central: complex tasks trigger autonomous skill creation, those skills self-improve during use, and the agent builds a persistent user model across sessions. That makes hermes-agent meaningfully different from stateless agents that reset with every conversation. The OpenClaw migration path (hermes claw migrate) is also strategically interesting — it is designed to absorb the installed base from OpenClaw as that project transitions to foundation governance, which gives it a rare head start on real-world adoption.

Under the Hood

The agent core is Python with a full TUI built for multiline editing, slash-command autocomplete, conversation history, and interrupt-and-redirect. Skills are compatible with the open agentskills.io standard. The repo includes Atropos RL environments and trajectory compression tooling for training next-generation tool-calling models, which signals that Nous is using hermes-agent’s production usage to generate training data. A one-line curl installer handles Python, Node.js, and all dependencies on Linux, macOS, and WSL2.

hermes-agent is what a serious, long-lived personal AI agent runtime looks like when memory and learning are treated as infrastructure rather than features.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

💻 emdash (GitHub) 3.7k ☆ — Open-source Agentic Development Environment for running parallel coding agents

The Scoop: emdash is a YC W26-backed, provider-agnostic desktop app that lets developers run multiple coding agents in parallel, each isolated in its own git worktree, either locally or over SSH on a remote machine. It supports 22 CLI providers including Claude Code, Qwen Code, Codex, Gemini CLI, Cursor, and Amp, and integrates with Linear, GitHub Issues, and Jira for ticket-to-agent handoffs. Diff review, PR creation, CI/CD check visibility, and merge are all handled from within the app.

Get started: download the installer for macOS, Windows, or Linux from the releases page, or run brew install --cask emdash on macOS.

📁 fff.nvim (GitHub) 3.8k ☆ — Rust-powered fuzzy file finder for Neovim with a dedicated background index

The Scoop: fff.nvim (Finally a Fabulous Fast Fuzzy File Finder) is an opinionated Neovim file picker backed by a native Rust runtime that maintains a persistent file index, tracks frecency, integrates git status, and delivers sub-10ms search across 50k-file codebases. It supports typo-resistant fuzzy search, live grep with plain, regex, and fuzzy modes, image previews, multi-select with quickfix integration, and cross-mode suggestions when a search returns no results.

Get started: add the plugin via lazy.nvim with the build hook to auto-download or compile the Rust binary, then map ff to require('fff').find_files() and fg to require('fff').live_grep().

🧪 AI-Scientist-v2 (GitHub) 5k ☆ — End-to-end agentic system for autonomous scientific paper generation via tree search

The Scoop: AI Scientist-v2 from Sakana AI is a fully autonomous research pipeline that generates hypotheses, runs ML experiments, analyzes results, and writes scientific manuscripts — without human-authored templates. Unlike v1, it generalizes across machine learning domains and uses a progressive best-first tree search (BFTS) guided by an experiment manager agent. It generated the first workshop paper written entirely by AI and accepted through peer review at ICLR 2025. Cost per full run is roughly $20–25 using Claude 3.5 Sonnet for experiments and GPT-4o for citations.

Get started: clone the repo, run conda create -n ai_scientist python=3.11, install requirements, create a topic description Markdown file, run perform_ideation_temp_free.py to generate ideas, then launch the full pipeline with launch_scientist_bfts.py.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

In this issue, we are doing something a bit different, we are starting from a market map: Hugging Face’s new “State of Open Source on Hugging Face: Spring 2026” report, released in mid-March. And the picture it paints is hard to ignore.

The report argues that open-source AI is no longer a side lane to frontier AI - it is increasingly where practical AI development happens. Hugging Face went from roughly 1.8m public models and 450k public datasets in 2024 to around 13m users, 2m+ public models, and 500k+ public datasets in 2025, with users creating not just downloads but derivative artifacts: fine-tunes, adapters, benchmarks, and applications. That is the key shift. Open source is no longer just a release mechanism for labs. It is the execution layer where models get adapted, deployed, and redistributed into real workflows.

The biggest story in the report is geographic. China has now overtaken the US in both monthly and overall Hugging Face downloads, with Chinese models accounting for 41% of downloads over the past year. DeepSeek may have been the symbolic turning point, but the broader signal is more important: Chinese organizations like Baidu, ByteDance, Tencent, and Alibaba are now shaping the open model layer at a pace the rest of the ecosystem has to respond to.

That matters because distribution in open source increasingly compounds through reuse. Alibaba’s Qwen family alone has spawned more than 113k derivative models, and more than 200k tagged variants if you count the broader ecosystem around it. In other words, leading open models are no longer just endpoints - they are base layers for thousands of downstream products, wrappers, quantizations, fine-tunes, and domain-specific systems. If OpenClaw showed what viral OSS looks like in agent infrastructure, Qwen shows what platform gravity looks like in open models.

That is the lens for this issue: not one repo taking over GitHub, but a broader handoff in where open-source AI momentum now sits. The next phase may be defined less by who trains the single best model, and more by who becomes the default substrate everyone else builds on.

🧰 Qwen3 (GitHub) 26.9k ☆ - Open-weight model family becoming a default base layer for downstream AI

The Scoop: OpenClaw is a self-hosted, model-agnostic AI agent runtime that connects to messaging apps like WhatsApp, Telegram, Slack, Discord, Signal, iMessage, and Teams. Running as a long-lived gateway on your machine, it can execute tools, manage files, run scripts, schedule tasks, and extend itself through skills. In February 2026, creator Peter Steinberger announced he is joining OpenAI while OpenClaw transitions toward foundation governance to remain open and independent.

Why It’s a Big Deal

• It captures the real power shift in OSS AI: winning is no longer just about releasing a strong model, but about becoming the family everyone fine-tunes, quantizes, serves, and builds on.

• Qwen sits at the center of the report’s biggest macro point - Chinese open models are no longer just competitive, but increasingly defining the direction and adoption curve of the open ecosystem.

• Its strength comes from ecosystem gravity, not just benchmark performance: broad tooling support, multiple sizes, permissive licensing, and easy local deployment make it highly reusable.

Under the Hood

• One repo, many entry points: instruct and thinking variants, larger MoE-style models, smaller local options, and support for long-context workloads up to 256k tokens, with extension up to 1m in newer releases.

• Designed for broad portability across the open inference stack, with first-class guidance for Transformers, vLLM, SGLang, TensorRT-LLM, Ollama, llama.cpp, MLX, OpenVINO, and mobile-oriented runtimes.

• Apache 2.0 licensing plus strong quantization and fine-tuning pathways make Qwen3 unusually easy to adapt into downstream products, wrappers, and domain-specific systems.

Qwen3 is not just another popular model repo - it is a strong example of how open models become platforms once the ecosystem decides they are easy to build around.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🧪 autoresearch (GitHub) 42.8k ☆ - Autonomous overnight experimentation for single-GPU model training

The Scoop: autoresearch is Andrej Karpathy’s minimal framework for letting an AI agent run real LLM training experiments overnight on a single GPU. The setup is intentionally tight: the agent edits one training file, runs a fixed five-minute experiment, checks whether the model improved, and iterates.

Why It’s a Big Deal

• It turns model research into an agent-native loop, where the LLM is not just helping with code but actually running bounded empirical experiments end-to-end.

• The design is unusually legible: one GPU, one editable file, one metric, and a fixed five-minute wall-clock budget make the whole system easy to reason about.

• It points to a broader shift in OSS AI tooling from static copilots toward closed-loop systems that can test, compare, and improve themselves.

Under the Hood

• The repo revolves around three files: prepare.py for fixed setup and utilities, train.py as the only mutable file, and program.md as the human-written instruction layer for the agent.

• Every experiment runs for exactly five minutes and is measured on val_bpb, a vocab-size-independent validation metric designed to keep comparisons fair across architectural changes.

• The codebase is deliberately self-contained and minimal, built around a simplified single-GPU nanochat training stack with no distributed setup or large config machinery.

autoresearch feels like a clean early example of what happens when prompting becomes experimental infrastructure.

⌨️ CLI-Anything (GitHub) 19k ☆ - Agent-native CLI generation for existing software

The Scoop: CLI-Anything turns existing software into agent-native CLIs. Instead of relying on brittle UI automation, it generates structured command-line interfaces for real tools like Blender, GIMP, LibreOffice, OBS Studio, and more.

Why It’s a Big Deal

• It treats the CLI as the universal control surface for agents, which is a much bigger thesis than adding isolated AI features to individual apps.

• The breadth of supported software suggests this can become a repeatable interface layer, not just a set of one-off demos.

• Its reliance on real backends rather than toy reimplementations gives it much stronger infrastructure potential.

Under the Hood

• The system follows a seven-phase pipeline covering analysis, design, implementation, testing, documentation, and publishing.

• Generated CLIs support both REPL usage and subcommand-based scripting, with built-in JSON output for structured agent use.

• The repo highlights 1,720 passing tests across 16 software demos and auto-generated SKILL.md files for agent discovery.

CLI-Anything is a strong example of OSS moving from agent apps toward agent interface infrastructure.

📎 paperclip (GitHub) 29.4k ☆ - Open-source orchestration for zero-human companies

The Scoop: paperclip is an orchestration layer for running teams of AI agents like a company rather than a pile of bots. It provides a dashboard for goals, budgets, org charts, tickets, and governance across multiple agents and runtimes.

Why It’s a Big Deal

• It pushes the agent conversation beyond single assistants and into organizational software, with hierarchy, budgeting, and accountability built in.

• The repo is interesting because it focuses on the operating layer around agents rather than trying to be yet another agent framework.

• Its “zero-human companies” framing is bold, but it usefully forces the product to think like business software instead of a chat tool.

Under the Hood

• The product combines a Node.js server and React UI with support for org charts, heartbeats, goal alignment, ticketing, and cost controls.

• It is explicitly bring-your-own-agent, supporting tools like OpenClaw, Claude Code, Codex, Cursor, Bash, and HTTP-based systems.

• The architecture emphasizes safeguards like atomic task checkout, persistent agent state, revisioned config changes, and budget enforcement.

paperclip shows what agent OSS looks like when it starts taking the shape of operating software rather than developer tooling.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🌍 Crucix (GitHub) 4.8k ☆ - Personal intelligence terminal for live world monitoring

The Scoop: Crucix is a local-first intelligence dashboard that aggregates 27 OSINT sources into one Jarvis-style monitoring stack, spanning markets, conflicts, radiation, flights, satellites, and social feeds, with alerts and optional LLM briefings.

Get started: try the public demo at crucix.live first, then clone the repo, configure .env, and run npm run dev or docker compose up.

🎨 impeccable (GitHub) 10.7k ☆ - Design steering system for AI-generated frontend work

The Scoop: impeccable is a design language layer for AI-assisted frontend generation, built around one skill, 20 steering commands, and explicit anti-patterns to push models away from repetitive AI design tropes.

Get started: visit impeccable.style, download the bundle for your tool, and install it into Cursor, Claude Code, OpenCode, Gemini CLI, Codex CLI, or another supported environment.

🧱 openui (GitHub) 2k ☆ - Open standard and runtime for generative UI

The Scoop: openui is a full-stack framework for generative UI built around OpenUI Lang, a compact streaming-first language for model-generated interfaces that aims to be much more token-efficient than JSON.

Get started: run npx @openuidev/cli@latest create --name genui-chat-app, add your API key to .env, and start the scaffolded app with npm run dev.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Let’s not dance around it: 2026 is the year the agentic stack is getting built in public, and it’s happening fast.

DeerFlow is the loudest signal this fortnight. ByteDance - yes, the TikTok company - open-sourced a production-ready super agent harness that hit #2 on GitHub Trending within 24 hours and crossed 25k stars inside two weeks. But the star count isn’t the story. The story is what DeerFlow actually ships: sandboxed code execution, persistent cross-session memory, specialized sub-agents for research and coding, Kubernetes deployment, and a human-in-the-loop review layer - all out of the box, all in a single git clone. Most agent frameworks hand you a toolkit and a blank page. DeerFlow hands you a running engine.

What’s striking is the timing. The same week DeerFlow landed, Alibaba shipped OpenSandbox - a general-purpose sandbox runtime that lets agents execute untrusted code in isolated Docker and Kubernetes environments, with SDKs in five languages and an MCP server for tool-compatible agents. Two of the world’s largest tech companies, both shipping foundational agent infrastructure, in the same week, in public. That’s not a coincidence - that’s a platform shift.

But the most quietly impressive thing that crossed our radar this issue wasn’t from a tech giant. World Monitor is a solo-built, open-source global intelligence dashboard that aggregates military activity, geopolitical news, maritime and aviation tracking, satellite fire detection, and infrastructure data into a single situational awareness interface - with AI-synthesized threat briefs, statistical anomaly detection, and 25 toggleable map layers. The kind of tool that OSINT analysts used to pay thousands a month for.

Strip away the corporate logos and what you have is the same thesis landing from multiple directions: the bottleneck for AI agents in 2026 isn’t the models. It’s the infrastructure. Safe execution environments. Memory that persists across sessions. Parallel task orchestration without agents stomping on each other’s work. Retrieval that doesn’t degrade when documents change. The models are good enough. The plumbing isn’t there yet - and that’s exactly what this week’s repos are all racing to build.

The rest of this issue covers the ones worth watching: two parallel-agent terminals fighting for your workflow, a vectorless RAG system that navigates documents the way a human expert would, an adaptive web scraper that survives site redesigns, a WiFi sensor that sees through walls without a camera, and the OSINT dashboard that made us do a double-take. The agentic stack is being assembled in real time. Here’s where the pieces are coming from.

🌐 worldmonitor (GitHub) 32.8 ☆ - Open-Source OSINT Dashboard That Rivals $$$-Tooling

The Scoop: World Monitor is a real-time global intelligence dashboard that aggregates geopolitical news, military activity, maritime and aviation tracking, infrastructure data, and AI-synthesized threat analysis into a single situational awareness interface — for free. The kind of thing that used to require an enterprise OSINT subscription now runs from a single npm run dev. There’s a live demo at worldmonitor.app, and a Tech variant (tech.worldmonitor.app) that swaps the geopolitics layer for AI/startup ecosystem monitoring — both from the same codebase.

Why It’s a Big Deal

• The signal intelligence architecture is genuinely sophisticated, not just a news aggregator with a map bolted on. It runs temporal baseline anomaly detection using Welford’s online algorithm — learning what “normal” military flight activity looks like on a Tuesday in January, then flagging when it deviates by 1.5, 2.0, or 3.0 standard deviations.

• The threat classification pipeline is a smart two-stage design: a keyword classifier fires instantly so the UI is never blocked, then an async LLM call (Groq Llama 3.1 8B) refines the result in the background and overrides only if its confidence is higher.

• The geographic convergence detection is the feature that makes this genuinely useful for analysis rather than just monitoring. It bins events into 1°×1° cells — when protests, military flights, and satellite fire detections all show up in the same cell within 24 hours, it escalates.

Under the Hood

• 30+ Vercel Edge Functions serve as a lightweight API layer — each handling a single data source (GDELT, ACLED, OpenSky, NASA FIRMS, Cloudflare Radar, AIS, Polymarket) so there’s no monolithic backend.

• 25 map layers rendered with deck.gl and MapLibre GL cover everything from 220+ military bases and nuclear facilities to undersea cables, AI datacenters, and real-time maritime vessel clustering.

• A Country Instability Index (0–100) blends baseline structural fragility (40%), protest/unrest events (20%), military activity from own and foreign forces (20%), and news velocity (20%).

World Monitor is the kind of project that makes you wonder why this wasn’t open source already. The live demo alone is worth bookmarking.

Get started: git clone https://github.com/koala73/worldmonitor.git && npm install && npm run dev

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

📡 RuView (GitHub) 29.2k ☆ - WiFi Signals as an Invisible Sensor

The Scoop: RuView does something that sounds like science fiction but is grounded in published research: it turns commodity WiFi signals into real-time human pose estimation, vital sign monitoring, and presence detection — all without a single pixel of video. GitHubUsing Channel State Information (CSI) extracted from an $8 ESP32-S3 microcontroller, it tracks 17 body keypoints through walls, detects breathing and heartbeat at over 11,000 fps, and runs entirely locally. No camera. No cloud. Just radio waves and math.

Why It’s a Big Deal

• The hardest problem with WiFi sensing is that every room is different — reflections, layouts, furniture all change how signals behave. RuView’s Project MERIDIAN tackles this with domain-adversarial training: it reduces cross-environment accuracy loss from 40–70% down to under 15% via 10-second automatic calibration. GitHubTrain once, deploy anywhere.

• Privacy-preserving sensing is a genuinely underexplored category. Hospitals, smart homes, elder care, security — anywhere you want presence and health data but cameras aren’t acceptable.

• 24 hot-loadable WASM modules run on-device on the ESP32-S3, covering signal intelligence, spatial reasoning, vital sign monitoring, and autonomous systems GitHub— so you can extend the firmware without reflashing.

Under the Hood

• Rust sensing server (132 MB Docker image) with a Python ML pipeline for those who want to train custom models.

• For higher accuracy with through-wall tracking, deploy 3–6 ESP32-S3 nodes in a multistatic mesh — each node acts as both transmitter and receiver, with TDM so they don’t interfere with each other. GitHub- No special hardware required to try it: docker run -p 3000:3000 ruvnet/wifi-densepose:latest runs a full simulated pipeline with synthetic data.

RuView is the kind of project that makes you re-evaluate what a “sensor” even is. If the hardware costs $8 and your router is already there, the question isn’t whether this gets deployed — it’s where.

Get started: docker run -p 3000:3000 ruvnet/wifi-densepose:latest or git clone https://github.com/ruvnet/RuView.git

🕷️ Scrapling (GitHub) 25.2k ☆ - The Web Scraper That Doesn’t Break When Sites Change

The Scoop: Scrapling is an adaptive Python web scraping framework. Its parser learns from website changes and automatically relocates your elements when pages update. Its fetchers bypass anti-bot systems like Cloudflare Turnstile out of the box. Its spider framework scales up to concurrent, multi-session crawls with pause/resume and automatic proxy rotation — all in a few lines of Python. Readthedocs The core insight: scraping pipelines don’t break because scraping is hard, they break because websites change. Scrapling solves the maintenance problem, not just the access problem.

Why It’s a Big Deal

• Adaptive parsing via auto_save=True means your CSS selectors survive site redesigns automatically — the framework uses similarity algorithms to find relocated elements without you rewriting anything.

• The built-in MCP server lets AI tools like Claude or Cursor directly use Scrapling to extract targeted content before passing it to the AI, reducing token usage and speeding up operations. GitHub It’s a natural fit for agentic pipelines that need reliable web data.

• 92% test coverage and full type hints coverage, and it’s been used daily by hundreds of web scrapers over the past year GitHub — this is production-grade, not a weekend project.

Under the Hood

• Three fetcher classes: Fetcher for fast HTTP with browser TLS fingerprint impersonation, StealthyFetcher for advanced anti-bot bypass, and DynamicFetcher for full Playwright-based browser automation.

• The v0.4 Spider framework adds a Scrapy-like API with async parse callbacks, multi-session routing, checkpoint-based pause/resume, and streaming mode for real-time stats. GitHub

• Full Docker image with all browsers pre-installed, an interactive IPython scraping shell, and a scrapling extract CLI for zero-code URL scraping from the terminal.

Scrapling is what BeautifulSoup would look like if it was built in 2025 and took anti-bot seriously from day one. The MCP integration is what pushes it into must-watch territory.

Get started: pip install scrapling && scrapling install

🦌 DeerFlow (GitHub) 25.3k ☆ - ByteDance’s Production-Ready Super Agent Harness

The Scoop: DeerFlow (Deep Exploration and Efficient Research Flow) is an open-source super agent harness from ByteDance that orchestrates sub-agents, memory, and sandboxes to handle almost anything — powered by extensible skills. GitHub It started as a deep research framework, but after the community started using it to build data pipelines, generate slide decks, spin up dashboards, and automate content workflows, ByteDance rebuilt it from scratch. DeerFlow 2.0 was released on February 27, 2026, immediately hit GitHub Trending #2, and reached 25k stars in under two weeks. byteiota

Why It’s a Big Deal

• Unlike most agent frameworks that expect you to build the rest yourself, DeerFlow ships as a more complete runtime — with filesystem access, skills, persistent memory, and sandboxed code execution out of the box. Kiledjian That lowers the barrier from “interesting research prototype” to “thing I can actually deploy.”

• DeerFlow remembers across sessions: it builds a persistent memory of your profile, preferences, and accumulated knowledge. The more you use it, the better it knows you — your writing style, your technical stack, your recurring workflows. GitHub

• Supports three deployment modes: local for dev, Docker for single-server production, and Kubernetes for scale — which tells you ByteDance designed this for real infrastructure.

Under the Hood

• Built on LangGraph for directed graph orchestration and LangChain for LLM reasoning. Model-agnostic: works with any OpenAI-compatible API endpoint.

• Skills and MCP servers extend its capabilities; OAuth token flows are supported for HTTP/SSE MCP servers. GitHub The community has already pushed it well beyond research into coding, content generation, and automation.

• Human-in-the-loop by design: the agent plans and surfaces its reasoning before executing, so you stay in control of long-horizon tasks.

DeerFlow is the “LangGraph plus batteries” that many teams have been quietly assembling themselves. The open-source release from ByteDance just means you don’t have to anymore.

Get started: git clone https://github.com/bytedance/deer-flow.git && uv sync

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

💻 superset-sh/superset (GitHub) 5.4k ☆ - The Terminal for Parallel Coding Agents

The Scoop: Superset is a turbocharged desktop terminal designed for the multi-agent era of development. Instead of context-switching between sessions, it lets you run multiple CLI coding agents simultaneously — Claude Code, Codex, or any other terminal-based agent — each isolated in its own git worktree so they don’t step on each other. You get a unified dashboard to monitor all agents at once and get notified when one needs input, plus a built-in diff viewer to quickly review changes. The core insight is that the bottleneck isn’t the agent’s speed — it’s yours. Ship more by waiting less.

Get started: Download the macOS desktop app from the releases page, or build from source: git clone https://github.com/superset-sh/superset.git && bun install && bun run dev

📦 alibaba/OpenSandbox (GitHub) 6.6k ☆ - The Open Sandbox Runtime for AI Agents

The Scoop: As coding agents get more powerful, they need safe places to run untrusted code at scale — and that’s exactly what OpenSandbox provides. It’s a general-purpose sandbox platform offering multi-language SDKs, unified lifecycle APIs, and Docker/Kubernetes runtimes purpose-built for scenarios like coding agents, GUI agents, AI code execution, and RL training. It provides secure execution environments for tools like Claude Code, GitHub Copilot, and Cursor to validate LLM-generated code in real time, with fine-grained network policy control and resource isolation. Think of it as the missing infrastructure layer between your agent and the host machine — standardized, scalable, and open source from Alibaba.

Get started: pip install opensandbox-server then opensandbox-server init-config ~/.sandbox.toml --example docker && opensandbox-server

🤖 emdash (GitHub) 2.4 ☆ - Provider-Agnostic Parallel Agent Orchestration

The Scoop: Emdash is a desktop app (YC W26) that treats your coding agents the way a project manager treats a team — dispatch many, monitor all, review results. It runs multiple CLI coding agents in parallel, each isolated in its own Git worktree so they can’t stomp on each other’s changes. It’s fully provider-agnostic, supporting 15+ agents out of the box — Claude Code, Codex, Gemini, Cursor, Copilot, Qwen Code, and more — so you’re not locked into any one model. The killer workflow: connect your Linear, GitHub, or Jira account, hand a ticket directly to an agent at workspace creation, and review the diff when it’s done. All state lives in a local SQLite database, so nothing touches their servers.

Get started: Download the macOS/Windows/Linux app from the releases page, or brew install --cask emdash

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

We cannot stop talking about OpenClaw. Few open-source projects have grown this fast, and few illustrate as clearly what OSS now represents in AI:

Some two weeks ago, OpenClaw-creator Peter Steinberger published an update that changes the OpenClaw story once again. He is joining OpenAI “to work on bringing agents to everyone,” while OpenClaw is planned to move into a foundation and remain open and independent. The framing is clear: keep the project OSS, but pair it with access to frontier research and broader distribution.

That is why we are covering OpenClaw again - for the third time in Repository Radar. In PR27 we described it as the most viral OSS project in recent memory. The trajectory since then reinforces the same point: OpenClaw has moved from a weekend experiment into infrastructure. The open question now is whether this is the final chapter of the original story, or the start of a more institutional phase under foundation governance.

The scale explains why this matters. Within roughly 3 months, OpenClaw climbed to rank 14 on GitHub by stars at around 222k stars, sitting above projects like Linux in that snapshot, while carrying thousands of open issues. That combination - explosive adoption plus operational load - is exactly what pushes ecosystems to split. Lightweight alternatives and focused reimplementations start appearing to reduce complexity, improve security posture, or make the core agent loop easier to understand.

That is the lens for this issue: projects that rose in the shadow of OpenClaw’s success. Instead of competing head-on, many are shrinking the surface area, tightening scope, or specializing around specific workflows. The ecosystem is no longer about one assistant, but about multiple ways to run the same underlying idea.

🧰 OpenClaw (GitHub) 222k ☆ - Personal AI assistant infrastructure across messaging platforms

The Scoop: OpenClaw is a self-hosted, model-agnostic AI agent runtime that connects to messaging apps like WhatsApp, Telegram, Slack, Discord, Signal, iMessage, and Teams. Running as a long-lived gateway on your machine, it can execute tools, manage files, run scripts, schedule tasks, and extend itself through skills. In February 2026, creator Peter Steinberger announced he is joining OpenAI while OpenClaw transitions toward foundation governance to remain open and independent.

Why It’s a Big Deal

• It reframes the personal assistant as local infrastructure rather than a SaaS product, putting control of data and execution back on the user side.

• The move toward foundation governance signals how quickly OSS agent runtimes are becoming ecosystem-level projects rather than single-maintainer repos.

• Its scale and visibility have triggered a wave of smaller, more opinionated variants that now define the next phase of experimentation.

Under the Hood

• Long-running runtime that connects messaging channels, LLM providers, and local tools into a unified execution loop.

• Model-agnostic architecture supporting cloud and local models with extensibility through skills and plugins.

• Operational reality at scale: roughly 222k stars and thousands of open issues, making governance and security architecture core challenges.

OpenClaw is no longer just a project - it is the substrate that other projects now react to, simplify, or rebuild in their own image.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🐱 KittenTTS (GitHub) 10.9k ☆ - Lightweight text-to-speech for local AI workflows

The Scoop: KittenTTS is a compact text-to-speech system designed for fast local inference. It focuses on producing natural speech while keeping the runtime small enough to run alongside local agent stacks without heavy infrastructure.

Why It’s a Big Deal

• Local TTS removes a major dependency for fully self-hosted agents.

• Small runtime footprint makes voice interfaces practical on commodity hardware.

• Fits naturally into agent workflows that need fast voice output without cloud latency.

Under the Hood

• Optimized neural TTS pipeline designed for efficient local inference.

• Lightweight model design aimed at low-resource environments.

• Simple integration path for agent frameworks and automation scripts.

KittenTTS is part of the shift toward local-first agent stacks where voice becomes just another tool call.

🦀 nanoclaw (GitHub) 13.6k ☆ - Security-first minimal OpenClaw alternative

The Scoop: nanoclaw is a minimal reimplementation of the OpenClaw concept, focused on readability and security. It keeps the core agent loop while reducing complexity and emphasizing isolation.

Why It’s a Big Deal

• Smaller codebase makes auditing and experimentation easier.

• Security-first architecture uses isolation instead of permission prompts.

• Shows how OSS ecosystems rapidly spawn minimalist variants after breakout success.

Under the Hood

• Built around Anthropic’s Agents SDK with a minimal structure.

• Containerized execution boundaries.

• Extension model based on skill files instead of heavy plugin systems.

nanoclaw represents the “minimal fork” phase that often follows large OSS projects.

🧩 picoclaw (GitHub) 12.1k ☆ - Ultra-lightweight personal agent runtime

The Scoop: picoclaw pushes the lightweight philosophy further, aiming for an ultra-small runtime that preserves the core OpenClaw interaction model while minimizing dependencies and complexity.

Why It’s a Big Deal

• Demonstrates rapid experimentation around the OpenClaw pattern.

• Prioritizes portability and fast onboarding.

• Encourages modular agent architecture over monolithic runtimes.

Under the Hood

• Minimal runtime focused on core messaging and tool execution.

• Low dependency footprint.

• Simple extension model for rapid customization.

picoclaw shows how ecosystems compress complexity once a reference implementation becomes dominant.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🧠 llmfit (GitHub) 3.7k ☆ - Lightweight fine-tuning workflows for LLMs

The Scoop: llmfit simplifies model fine-tuning workflows, aiming to reduce the configuration overhead required to adapt models for specific tasks or domains.

Get started:

pip install llmfit

🦞 LobsterAI (GitHub) 1.9k ☆ - Modular AI agent experimentation framework

The Scoop: LobsterAI provides a modular environment for experimenting with agent workflows and tool integrations, emphasizing composability over rigid orchestration.

Get started: clone the repo (git clone https://github.com/netease-youdao/LobsterAI.git) and follow the quickstart guide in the README.

🕷️ PentAGI (GitHub) 7.9k ☆ - Autonomous offensive security agent

The Scoop: PentAGI is an AI-driven penetration testing framework that automates offensive security workflows using agent-style execution loops.

Get started: it clone the repo and run via Docker or local setup.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Let’s not dance around it: OpenClaw is the most viral open-source project in recent memory. 183k stars. 2 million visitors in a single week. Three name changes (Clawdbot → Moltbot → OpenClaw) after Anthropic’s legal team had a word. A malicious VS Code extension that appeared within hours of a rename. Crypto scammers snatching abandoned Twitter handles. The hype cycle hit every beat, and somehow the project came out the other side stronger.

But strip away the drama and what you actually have is a long-running Node.js gateway that sits on your machine and connects AI models to your messaging apps - WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, you name it. You talk to it through the apps you already use. It can read and write files, run scripts, control browsers, schedule cron jobs, and extend itself by writing its own skills. It’s your assistant, your machine, your keys. That’s the pitch.

What makes OpenClaw worth tracking beyond the hype is the positioning shift. Steinberger now explicitly describes it as infrastructure, not an app. The trajectory - from “WhatsApp Relay” to personal assistant to model-agnostic agentic infrastructure - mirrors where the entire space is heading. OpenClaw is betting that the future of AI isn’t a new app, it’s AI embedded in the apps you already use. Whether that bet is right or catastrophically premature depends on whether the security story catches up to the capability story. Right now, it hasn’t.

That gap is exactly what makes the ecosystem around OpenClaw so interesting. Projects are emerging to solve the parts that OpenClaw itself punts on - memory that actually scales for 24/7 agents, lightweight reimplementations you can actually audit, orchestration layers that handle multi-agent coordination. The rest of this issue covers the ones worth watching.

🧰 OpenClaw (GitHub) 183k ☆ - Your own personal AI assistant. Any OS. Any platform. The lobster way. 🦞

The Scoop: OpenClaw is a self-hosted, model-agnostic AI agent that runs as a Node.js gateway on your own machine and connects to the messaging apps you already use. You talk to it through WhatsApp, Telegram, Slack, Discord, Signal, iMessage, or Teams - and it can read and write files, run shell commands, control browsers, schedule tasks via cron, and extend its own capabilities by writing new skills autonomously. Originally launched as “Clawdbot” in November 2025 by Peter Steinberger (of PSPDFKit fame), it went through two renames and three security incidents on its way to becoming one of the fastest-growing open-source projects ever.

Why It’s a Big Deal

• It reframes the personal AI assistant as local infrastructure rather than a SaaS product - your machine, your keys, your data, no subscription beyond the model API cost.

• Multi-channel inbox with multi-agent routing means you can run isolated agents per channel, each with their own workspace and session context.

• The skills and plugin system lets the agent self-improve by writing code to handle tasks it couldn’t do before, which is both the most powerful and most terrifying part.

Under the Hood

• Long-running Node.js service with a WebSocket control plane that manages sessions, presence, config, cron, webhooks, and a web-based Control UI.

• Supports any LLM provider (Anthropic, OpenAI, xAI/Grok, local models via Ollama) with explicit recommendation for Opus 4.6 for prompt-injection resistance.

• Ships with onboarding wizard, macOS menu bar companion, iOS/Android nodes, voice wake mode via ElevenLabs, and a Live Canvas for agent-driven visual workspaces.

OpenClaw is not a polished product - it’s a fast-moving, sometimes dangerous, community-driven agent runtime that has outgrown its weekend-project origins. Whether it becomes the Linux of personal AI or flames out under the weight of its own security surface area depends entirely on what happens in the next six months.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🧰 ChatDev 2.0 (GitHub) 30k ☆ - Zero-code multi-agent orchestration platform

The Scoop: ChatDev started in 2023 as a research demo - a “virtual software company” where LLM agents playing CEO, CTO, and Programmer would talk to each other to build software. Cute, but limited. The 2.0 release in January 2026 is a different animal entirely. Rebranded as DevAll, it’s now a zero-code multi-agent platform where you define agent workflows in YAML, pick from pre-built or custom agent roles, and launch them from a visual interface. Software development is just one template among many.

Why It’s a Big Deal

• It went from “fun research demo” to a general-purpose agent orchestration layer - you can wire up multi-agent pipelines for data analysis, content generation, or any structured task, not just coding.

• YAML-based workflow definitions mean non-developers can build and modify agent pipelines without touching Python.

• The MacNet branch supports collaboration topologies with 1,000+ agents without blowing context limits, backed by an ICLR 2025 paper.

Under the Hood

• Built in Python with a ChatChain architecture that composes Phases (units of work) into configurable pipelines, each with its own agent roles and prompts.

• Ships a web visualizer that replays agent conversations and renders the full workflow as an interactive diagram.

• Supports per-phase LLM routing (different models for different agent roles) and includes Git-mode for automatic version control of generated artifacts.

ChatDev 2.0 is the clearest sign that multi-agent orchestration is becoming a product category of its own, separate from the models and separate from the end-user assistants like OpenClaw that consume it.

🤖 nanobot (GitHub) 15.9k ☆ - The ultra-lightweight Clawdbot

The Scoop: nanobot is what happens when an academic lab looks at OpenClaw’s 170k-line codebase and says “we can do this in 4,000 lines.” Built by the Data Intelligence Lab at HKU, it reimplements the core OpenClaw agent loop - LLM-driven task execution, tool use, cron jobs, persistent memory, subagents, multi-channel messaging - in clean, readable Python. It’s explicitly positioned as a research-ready alternative: same concept, 99% less code.

Why It’s a Big Deal

• You can actually read and understand the entire agent loop in an afternoon, which makes it a real starting point for research and customization rather than a black box.

• Supports the same provider ecosystem (OpenRouter, Anthropic, local models via vLLM) and channel integrations (Telegram, WhatsApp) without the infrastructure overhead.

• Docker and pip install paths mean you go from zero to working agent in about two minutes, no wizard required.

Under the Hood

• Pure Python with a clean separation: agent/loop.py for the core LLM↔tool cycle, agent/memory.py for persistence, agent/subagent.py for background task delegation.

• Config lives in a single ~/.nanobot/config.json - one file, no YAML hierarchy, no env var maze.

• Ships built-in tools for browser automation, file operations, and shell access, with a skills loader for extending via custom tool definitions.

nanobot is to OpenClaw what Alpine Linux is to Ubuntu - stripped to the essentials, designed to be understood, and built for people who want to know exactly what’s running on their machine.

🧩 cognee (GitHub) 12.2k ☆ - Memory infrastructure for AI agents

The Scoop: cognee replaces traditional RAG with a unified memory layer built on knowledge graphs and vector search. Its ECL pipeline (Extract, Cognify, Load) ingests from 30+ data sources - conversations, files, images, audio transcriptions - and builds a structured graph that agents can query through MCP. Where most RAG setups chunk text and hope cosine similarity finds the right passage, cognee turns your data into a web of entities and relationships that agents can actually reason over. Think of it as the plumbing layer: less flashy than a personal assistant, but the thing that makes retrieval actually accurate.

Why It’s a Big Deal

• It unifies vector search and graph databases into a single memory layer, so documents are both searchable by meaning and connected by relationships - not one or the other.

• Graduated from GitHub’s Secure Open Source Program, which matters when you’re building the memory layer that production AI systems depend on.

• Ships an MCP server out of the box, which means any MCP-compatible agent (Claude Code, OpenClaw, Cursor) can use cognee as its memory backend without custom integration work.

Under the Hood

• Python framework with modular pipelines: add data, cognify it (extract entities, build graphs, generate embeddings), then search across the resulting knowledge structure.

• Supports Neo4j, Kuzu, and NetworkX for graph storage and PostgreSQL, Qdrant, or Weaviate for vectors - swap backends without changing application code.

• CLI, FastAPI server, and a Next.js frontend for browsing the knowledge graph visually, plus full Docker support for self-hosted deployment.

cognee is the kind of infrastructure project that doesn’t go viral but quietly becomes load-bearing. If the agent ecosystem keeps growing at this pace, the memory layer underneath it needs to be this solid.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🧠 memU (GitHub) 8.8k ☆ - Memory for 24/7 proactive agents

The Scoop: memU is a memory framework built specifically for the kind of always-on, proactive agents that OpenClaw represents. The core problem it tackles: keeping an agent online 24/7 burns through LLM tokens fast, and naive context stuffing doesn’t scale. memU structures memory as a hierarchical file system - Resource Layer → Memory Item Layer → Category Layer - and uses continuous learning to build long-term understanding of user intent without bloating the context window.

Get started: run git clone https://github.com/gavrielc/nanoclaw.git and cd nanoclaw and claude

🦀 nanoclaw (GitHub) 6.9k ☆ - Security-first minimal OpenClaw alternative

The Scoop: nanoclaw takes the opposite approach to OpenClaw’s kitchen-sink philosophy. It’s a handful of source files you can read in 8 minutes, built on Anthropic’s Agents SDK, and - crucially - runs agents inside Apple Containers (or Docker) with real filesystem isolation instead of permission prompts. Setup is literally git clone then telling Claude Code to run /setup. Instead of PRs that add features, it uses Claude Code skill files that teach users how to transform their own fork. Opinionated, minimal, and the only OpenClaw alternative that treats security as an architecture decision rather than an afterthought.

Get started: git clone https://github.com/gavrielc/nanoclaw.git && cd nanoclaw && claude, then run /setup

📑 PageIndex (GitHub) 14.6k ☆ - Vectorless, reasoning-based RAG

The Scoop: PageIndex throws out the vector database entirely. Instead of chunking documents and doing similarity search, it builds a hierarchical tree index (like a table of contents) and uses LLM reasoning to navigate that tree - the way a human expert would flip through a report to find what they need. Inspired by AlphaGo’s tree search, it hit 98.7% accuracy on FinanceBench, which is state-of-the-art for financial document QA. Available as a self-hosted framework, an MCP server, or a hosted chat platform.

Get started: pip install pageindex, then check out the Vectorless RAG cookbook notebook on GitHub.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Some two weeks ago Anthropic launched Claude Cowork, a general-purpose AI agent that can manipulate, read, and analyze files on a user’s computer, and create new files. It is currently a research preview available to Max subscribers on 100 USD or 200 USD per month plans.

Cowork is positioned as “Claude Code for the rest of your work,” targeting non-technical users who want agentic workflows without a developer-first terminal interface. Anthropic demoed practical desktop use cases like reorganizing downloads, converting receipt screenshots into expense spreadsheets, and drafting documents from notes across a user’s machine.

The competitive implication is clear: once foundation model vendors ship file agents inside their core subscription, a large surface area of “workflow wrapper” startups gets squeezed. The differentiator shifts from “we added an agent to X” toward who owns the UX, the permissions model, and the extensibility layer.

That makes OpenWork interesting as an OSS counterpoint: it takes the agent loop and turns it into a productized, permissioned desktop experience that can be run locally or pointed at remote servers, without being locked to a single vendor UI. Alongside projects like Moltbot (formerly Clawdbot, which we covered in Repo Radar PR#25 and has since seen rapid adoption), this shows that capable desktop agents are emerging in the open, not just from foundation model vendors.

🧰 OpenWork (GitHub) 7.3k ☆ - Open source “Claude Work” for knowledge workers

The Scoop: OpenWork is an extensible, open-source desktop app that wraps OpenCode into a guided workflow for non-technical users. It focuses on making agentic work feel like a product, with workspaces, session runs, streaming progress, and permission prompts instead of a terminal-first interface.

Why It’s a Big Deal

• It translates OpenCode-style agent workflows into a UI that non-developers can actually use day to day.

• Host mode and client mode let teams run locally for privacy, or connect to remote OpenCode servers for shared infra.

• Built-in permission surfacing and auditability make it easier to ship agentic workflows in real organizations.

Under the Hood

• Built as a native desktop app using Tauri and Rust, with a TypeScript UI and OpenCode running under the hood.

• Uses SSE event streaming to show realtime plan updates, progress, and permission requests.

• Extends via OpenCode plugins and skills, managed through opencode.json at project or global scope.

OpenWork is the cleanest OSS attempt so far at turning “agent in a terminal” into a real end-user product without surrendering control to a bundled vendor suite.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🌐 agent-browser (GitHub) 10.6k ☆ - Headless browser automation CLI for AI agents

The Scoop: agent-browser is a headless browser automation CLI designed specifically for AI agents. It provides a fast Rust CLI with a Node.js daemon that runs Playwright, plus an AI-friendly snapshot workflow using accessibility trees and deterministic element refs.

Why It’s a Big Deal

• The snapshot plus refs workflow makes browser automation more reliable for agents than fragile CSS selectors.

• A CLI-first interface makes it easy to plug into any agent harness, from Claude Code to Codex to OpenCode.

• Provider support enables cloud browser execution when local browsers are not feasible in CI or serverless.

Under the Hood

• Uses a Rust CLI for speed and a persistent Node.js daemon for Playwright session management.

• Supports machine-readable JSON output for agents and deterministic refs like @e1, @e2 derived from snapshots.

• Integrates with remote browser providers like Browserbase, Browser Use, and Kernel via a provider flag or env vars.

agent-browser is becoming the default “browser tool” layer for agent stacks that need deterministic UI interaction without reinventing Playwright wrappers.

🧠 oh-my-opencode (GitHub) 24.2k ☆ - Batteries-included agent harness for OpenCode

The Scoop: Oh My OpenCode is a heavy-duty OpenCode plugin that turns the agent into a multi-model orchestrator with curated subagents, LSP and AST tooling, background tasks, and a Claude Code compatibility layer. It is opinionated, feature-rich, and built to keep agents executing until the task is complete.

Why It’s a Big Deal

• It packages orchestration patterns that usually live in private prompts into a reusable, installable harness.

• Multi-agent delegation and background tasks reduce main-context bloat and make large codebases more tractable.

• Claude Code compatibility makes it easier to migrate workflows and reuse skills, hooks, and MCP setups.

Under the Hood

• Implemented almost entirely in TypeScript and designed as an OpenCode plugin with project and user config support.

• Ships a hook system, curated MCPs, and LSP and AST-aware tooling for more deterministic refactors.

• Includes a main agent setup (”Sisyphus”) with supporting agents for planning, debugging, docs, and exploration.

Oh My OpenCode is the clearest sign that agent harnesses are becoming their own product category, with OSS power users shipping the missing runtime layer around frontier models.

🧾 x-algorithm (GitHub) 13.6k ☆ - Open source “For You” feed recommendation system

The Scoop: x-algorithm open-sources the core system powering the "For You" feed on X, combining in-network content from followed accounts with out-of-network retrieval from a global corpus. It ranks candidates using a Grok-based transformer that predicts engagement probabilities and composes them into a final weighted score.

Why It’s a Big Deal

• It provides a real-world, production-grade recommendation pipeline reference instead of toy ranking examples.

• The architecture shows how retrieval and ranking can be composed into a single system with explicit stages and interfaces.

• The move away from hand-engineered features signals a shift toward transformer-first ranking as the default approach.

Under the Hood

• Implemented primarily in Rust with components split into Home Mixer, Thunder, Phoenix, and Candidate Pipeline crates.

• Uses a two-tower retrieval model for out-of-network discovery and a transformer ranker with candidate isolation.

• Pipeline stages include hydration, filtering, multi-action scoring, selection, and post-selection visibility filtering.

x-algorithm is one of the most concrete open references for how modern transformer-based ranking systems are built, staged, and served at scale.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

📈 ChartGPU (GitHub) 2.2k ☆ - WebGPU charting for high-performance rendering

The Scoop: ChartGPU is a TypeScript charting library built on WebGPU for smooth, interactive visualization when you have lots of data. It supports multiple chart types including candlesticks and can stream updates via appendData(...) for cartesian series.

Get started:

npm install chartgpu

🤖 Ralph (GitHub) 7.8k ☆ - Autonomous agent loop for Amp and Claude Code

The Scoop: Ralph is an autonomous agent loop that runs AI coding tools (Amp or Claude Code) repeatedly until all PRD items are complete. Each iteration starts with clean context, and state persists through git history plus explicit artifacts like prd.json and progress.txt.

Get started: Copy ralph.sh plus CLAUDE.md (or prompt.md) into your repo, chmod +x, then run ./scripts/ralph/ralph.sh 10 (or ./scripts/ralph/ralph.sh --tool claude 10)

🧠 UltraRAG (GitHub) 4.3k ☆ - Low-code MCP framework for complex RAG pipelines

The Scoop: UltraRAG is a lightweight RAG development framework built around the Model Context Protocol architecture. It standardizes RAG components as MCP servers and orchestrates multi-step pipelines through YAML, with a UI that acts like a visual RAG IDE.

Get started: git clone the repo, then uv sync (or uv sync --all-extras), then ultrarag run examples/sayhello.yaml (Docker option available)

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now

📡 ABOVE THE RADAR (aka the BFD)

In “above the radar” we take a look at some of the big splash software infrastructure announcements and go on the hunt for OSS that are similar.

Anthropic is playing hardball. In the past seven months, they’ve cut off Windsurf, blocked OpenAI’s API access, and just this week revoked xAI employees’ ability to use Claude through Cursor. The pattern is clear: if you’re a competitor—or about to be acquired by one—your Claude access is a liability, not a feature.

The trigger was Claude Code hitting $1 billion in run-rate revenue. What started as a niche terminal tool became a phenomenon, partly thanks to the community-driven “Ralph Wiggum” technique—a brute-force loop that feeds failures back into context until tests pass. Developers started calling it “accidentally AGI.” Anthropic noticed. Now they’re locking down who gets to ride those rails.

This matters because MCP, the Model Context Protocol that Anthropic open-sourced a year ago, has become the de facto standard for AI-to-tool integration. OpenAI adopted it. Google adopted it. Microsoft adopted it. The MCP Registry now lists nearly 2,000 servers. But here’s the tension: Anthropic built the pipes, and now they’re deciding who gets to use the water.

For builders in the Claude Code ecosystem, the message is mixed. On one hand, Anthropic is clearly betting big on developer tooling—Claude Code, the “Code with Claude” conference, HIPAA-ready healthcare integrations. On the other, they’ve shown they’ll yank access with five days’ notice if competitive dynamics shift. Windsurf users learned this the hard way when they woke up to “bring your own key” as their only option.

The repos in this week’s lineup live in that tension. Tools like ralph-claude-code automate the exact loop patterns that drove Claude Code’s breakout. chrome-devtools-mcp and claude-code-templates extend Claude’s reach through the MCP standard Anthropic championed. ChatDev and skypilot offer multi-agent orchestration that doesn’t depend on any single provider’s good graces. And clawdbot lets you self-host across platforms—WhatsApp, Telegram, Discord—so your AI stack isn’t one policy change away from breaking.

The vibe-coding gold rush is on, but the ground is shifting under everyone’s feet. This week’s repos are tools for building on that terrain—whether you’re all-in on Claude or hedging your bets.

🏢 ChatDev (GitHub) 28.5k ☆ - Virtual software company powered by LLM agents

The Scoop: ChatDev simulates an entire software company with AI agents playing roles like CEO, CTO, Programmer, Reviewer, Tester, and Art Designer. Describe your idea in natural language and watch the agents collaborate through functional seminars—designing, coding, testing, and documenting—to produce working software. ChatDev 2.0 (DevAll) now extends this to a zero-code multi-agent orchestration platform for tasks beyond software: data visualization, 3D generation, and deep research.

Why It’s a Big Deal

• Research-backed framework with papers accepted at NeurIPS 2025 and ICLR 2025.

• Highly customizable: define your own ChatChains, Phases, and agent Roles via simple JSON configs.

• Scales to 1,000+ agents via MacNet (directed acyclic graph topologies) without blowing context limits.

Under the Hood

• Built in Python with a modular architecture: CompanyConfig defines workflows, PhaseConfig defines steps, RoleConfig defines agents.

• Supports OpenAI GPT-4/4o, incremental development on existing codebases, Human-Agent-Interaction mode, and Git version control.

• Includes a web visualizer, Docker support, and an Experiential Co-Learning module where agents learn from past tasks.

Get started: Clone the repo, set up Python 3.9+, install dependencies, export your OpenAI key, then run python3 run.py --task "design a 2048 game" --name "2048". Find your generated software in the WareHouse folder.

🔭 ON THE RADAR

Stuff that’s hot and is trending at over 10K stars.

🔧 chrome-devtools-mcp (GitHub) 20.8k ☆ - Chrome DevTools for coding agents

The Scoop: Official MCP server from the Chrome team that gives your AI coding assistant (Gemini, Claude, Cursor, Copilot) full access to Chrome DevTools. Record performance traces and get actionable insights, inspect network requests, take screenshots, check console logs, and automate browser actions with Puppeteer under the hood. Supports headless mode, custom Chrome channels, and connecting to already-running browser instances.

Why It’s a Big Deal

• Official Google/Chrome team project—first-party support and reliability.

• Works with all major AI coding tools: Claude Code, Cursor, Copilot, Gemini CLI, Windsurf, and more.

• 26 tools covering input automation, navigation, emulation, performance profiling, network inspection, and debugging.

Under the Hood

• Built on Puppeteer for reliable browser automation with automatic wait handling.

• Supports headless mode, custom Chrome channels (stable/canary/beta/dev), and WebSocket connections with custom headers.

• Can connect to already-running Chrome instances via remote debugging port or auto-connect (Chrome 145+).

Get started: Add to your MCP client config: "command": "npx", "args": ["-y", "chrome-devtools-mcp@latest"]. Then prompt "Check the performance of “https://example.com" and watch it open Chrome and record a trace.

📦 claude-code-templates (GitHub) 15.9k ☆ - Ready-to-use configs for Claude Code

The Scoop: A massive collection of 100+ agents, custom slash commands, settings, hooks, and MCP integrations for Claude Code—all installable via CLI. Browse and install frontend developers, security auditors, performance optimizers, and database architects. Includes built-in tools: session analytics dashboard, real-time conversation monitor, health checks, and plugin management.

Why It’s a Big Deal

• One-command installation for pre-configured AI specialists—no manual CLAUDE.md wrangling.

• Aggregates community contributions from multiple sources (Anthropic official, K-Dense scientific skills, and community repos).

• Interactive web interface at aitmpl.com for browsing before you install.

Under the Hood

• Components include agents, slash commands, MCPs (GitHub, PostgreSQL, Stripe, AWS), settings, hooks, and reusable skills.

• Conversation monitor supports secure remote access via Cloudflare Tunnel.

• Active development with 19 releases and 35 contributors.

Get started: npx claude-code-templates@latest to browse interactively, or install a full stack directly: npx claude-code-templates@latest --agent development-team/frontend-developer --command testing/generate-tests --yes

🎨 onlook (GitHub) 24k ☆ - Visual code editor for React + Tailwind

The Scoop: Dubbed “Cursor for Designers,” Onlook lets you visually build and edit Next.js + TailwindCSS apps in a Figma-like interface while AI writes the code. Create apps from text prompts or Figma imports, drag-and-drop elements directly in the browser DOM, preview code side-by-side, and deploy with one click. Open-source alternative to Bolt.new, Lovable, and V0.

Why It’s a Big Deal

• Bridges the designer-developer gap—visual editing that writes real, production-ready code.

  Full GitHub integration: import repos, create branches, open PRs directly from the editor.

  Open-source under Apache 2.0 with an active YC-backed team hiring in SF.

Under the Hood

• Built with Next.js, TailwindCSS, tRPC, Supabase, and Drizzle ORM.

• Uses CodeSandbox SDK for dev sandboxes and Freestyle for hosting.

• AI powered by OpenRouter and fast-apply models from Morph and Relace.

Get started: Use the hosted app at onlook.com or run locally following the docs. Import an existing Next.js project or start fresh with AI chat.

🔬 BELOW THE RADAR

Our hot picks for recent OSS projects to keep a close eye on for the future.

🔄 ralph-claude-code (GitHub) 2.5k ☆ - Autonomous dev loop for Claude Code

The Scoop: Ralph implements the “Ralph Wiggum” technique for Claude Code—a continuous autonomous development loop that iterates on your codebase until objectives are complete. Features intelligent exit detection (catches “done” signals, task completion, stuck loops), rate limiting with circuit breaker, 5-hour API limit handling, and tmux-based live monitoring. Converts PRDs into prioritized task lists automatically.

Get started: Clone the repo, run ./install.sh, then ralph-setup my-project to scaffold. Edit PROMPT.md with your goals and run ralph --monitor to let it rip.

🦞 clawdbot (GitHub) 3.9k ☆ - Personal AI assistant across all your messaging apps

The Scoop: Clawdbot is a self-hosted AI assistant that connects to WhatsApp, Telegram, Slack, Discord, Signal, iMessage, and Teams through a single Gateway. Runs locally on your devices with Voice Wake, Talk Mode (ElevenLabs), browser control, live Canvas, and agent-to-agent session routing. Built by Peter Steinberger for his space lobster AI “Clawd.” Works on macOS, iOS, Android, Linux, and Windows (WSL2).

Get started: npm install -g clawdbot@latest then clawdbot onboard --install-daemon. The wizard walks you through provider pairing and workspace setup.

☁️ skypilot (GitHub) 9.2k ☆ - Unified AI infrastructure orchestration

The Scoop: SkyPilot lets you run AI workloads across Kubernetes, 20+ clouds, or on-prem using a single YAML config. Define your job once (GPUs, setup, run commands) and SkyPilot handles provisioning, auto-failover on capacity errors, spot instance recovery, and cost optimization. Includes a web dashboard, gang scheduling, and built-in support for vLLM, DeepSpeed, and popular LLM training/serving stacks.

Get started: pip install -U "skypilot[kubernetes,aws,gcp,azure]" then define your task in a YAML file and run sky launch my_task.yaml. SkyPilot finds the cheapest available infra and handles the rest.

Repository Radar is brought to you by Alexander, a Partner at Picus Capital, and Claudius, the co-founder of Index Labs. In this Substack, we focus on software infrastructure and open-source innovation in AI and beyond, tracking major trends while uncovering the hidden gems shaping the future of technology.

Subscribe now