Repository Radar - PR#36
Keeping an eye on the world of OSS software - one scan at a time
Welcome to PR #36 of Repository Radar - your no-fluff scan of open-source software infrastructure. This issue’s theme: the agent is turning from a thing you call into a thing that runs. “Always-on” is becoming the default shape of an agent, and that rewrites what the stack needs - not better answers, but uptime, scheduling, supervision, and survival. We open with OpenFang, an agent OS built to run 24/7, then CopilotKit as the human window into a running agent, Mastra and VoltAgent as runtimes that persist and resume, and three below-the-radar picks - EvalView, Restate, and sayiir - that keep an always-on agent honest and alive.
📡 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
useAgenthook 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.