~/tools

Power-user tools log

A running catalog of agentic harnesses, runtimes, and repos the daily digest keeps finding. Deduped. No household CLIs. Each card is something you can clone and run.

[auto-updating] 502 tools · last updated 2026-10-27

repoGitHub

agentmemory↗

rohitg00

Persistent memory layer for coding agents that ranks high on real-world session and temporal retrieval benchmarks.

Use caseUse it to give any MCP or CLI coding agent durable cross-session recall without pasting full history.

memorymcpcoding-agentretrieval

repoGitHub

alt-agent-harness↗

mngaonkar

Tiny skill-based local agent harness that makes the model, tools and disk skills fully visible in one sitting.

Use caseUse it to learn and extend a minimal laptop agent loop with Anthropic-style skills folders.

harnessskillsminimallocal

harnessGitHub

Cordum↗

cordum-io

Agent control plane and action firewall that enforces policy and human approval before risky tool calls, shell commands and production changes with audit evidence.

Use caseUse it to insert a deterministic governance layer in front of any framework before agents act.

control-planepolicyauditsafety

repoGitHub

Cordum CAP↗

cordum-io

Open wire protocol for agent clusters that adds jobs, heartbeats, safety hooks and workflows over a message bus.

Use caseUse it to standardize how distributed agents coordinate and apply policy before dispatch.

protocolcontrol-planeclustersafety

toolGitHub

Greywall↗

GreyhavenHQ

Container-free deny-by-default sandbox for coding agents that enforces kernel filesystem, network and syscall isolation on Linux and macOS.

Use caseUse it to wrap Claude Code or similar CLIs so they cannot touch secrets outside the working tree.

sandboxisolationsecuritycli

harnessGitHub

Kitaru↗

zenml-io

Record-replay and improvement system that treats agent runs as evidence-rich sessions with evaluators and cohorts.

Use caseUse it to capture production agent traces, define evaluators and run bounded replay experiments.

evalobservabilityreplaysdk

harnessGitHub

agent-reliability↗

kladak

Reliability platform with schema-validated tool routing, JSONL traces, deterministic graders and CI regression gates.

Use caseUse it to add offline eval reports and fail-the-build gates to any tool-using agent loop.

evalreliabilitytracesci

harnessGitHub

agentplane↗

hupe1980

Durable, replayable Rust agent runtime whose journal is the single plan of record for every step and decision.

Use caseUse it to run agents that can be fully audited, replayed and resumed from a cryptographically consistent log.

runtimejournalrustreplay

toolGitHub

agents-sandbox↗

inoio

Launcher that places supported coding agents inside per-project microVMs while keeping secrets and host paths under operator control.

Use caseUse it to keep your existing agent CLI workflow yet isolate each repo and inject secrets only as placeholders.

sandboxmicrovmsecretslauncher

toolGitHub

coop↗

trailofbits

Rust CLI that spins disposable Firecracker or Lima VMs so coding agents get full Docker, git and compiler access with zero host risk.

Use caseUse it to launch Claude Code, Codex or Grok Build inside a fresh isolated VM per project and tear it down when done.

microvmisolationclifirecracker

harnessGitHub

Runtm↗

runtm-ai

Open-source sandboxes and control plane where coding agents build, test and deploy software with live HTTPS URLs, logs and previews.

Use caseUse it to let any coding agent ship real software inside isolated environments that expose instant preview endpoints.

sandboxdeployruntimecontrol-plane

harnessGitHub

Agensh↗

Microsoft Research (Zhihao Zhan et al.)

Self-organized multi-agent harness that scales to 1024 agents with async task claiming, shared workspace, and no central orchestrator.

Use caseUse it to spin up large peer teams that rebuild reference programs from observations on ProgramBench-style tasks.

multi-agentdecentralizedresearch-origin

toolGitHub Blog

Agent HQ primitives (open ecosystem view)↗

GitHub

Mission-control style orchestration surface that unifies assignment, steering and tracking of multiple coding agents across GitHub, VS Code, mobile and CLI.

Use caseUse it to study how a single control plane can route work to heterogeneous agents while keeping enterprise review and metrics.

orchestrationmission-controlmulti-agentplatform

repoGitHub

Awesome Harness Engineering↗

ai-boost

Curated map of harness engineering primitives covering context, tools, memory, sandboxes, permissions, evals and observability.

Use caseUse it to map the five harness primitives and find the matching open-source module for each.

awesome-listcontextmemorysandbox

harnessGitHub

DevOps Agent Harness↗

stwins60

Model-agnostic harness that turns any coding agent into a governed DevOps engineer with policy, approvals, audit, secret redaction and rollback enforced outside the LLM.

Use caseUse it to drive Jira-to-PR incident response or Kubernetes diagnosis while every tool call hits an external policy engine.

devopspolicymcpapprovals

harnessGitHub / DEV

Multiharness↗

eror-0

Go multi-agent orchestrator that delegates planner, implementer and reviewer roles across open coding harnesses with iterative review loops.

Use caseUse it to run a Codex planner plus OpenCode executor team on one folder with configurable reasoning levels.

multi-agentorchestrationgocoding

toolGitHub

SideKernel↗

minoansecurity

Zero-dependency macOS microVM sandbox using only Apple frameworks and a Rust guest agent for Claude and other coding agents.

Use caseUse it to launch an ephemeral Linux microVM from the current directory with sclaude or scodex wrappers.

macosmicrovmsandboxrust

harnessGitHub

agent-eval-harness↗

Siddharth-1001

Local-first evaluation framework that traces full agent behavior, not just LLM outputs, with structured metrics and side-by-side comparisons.

Use caseUse it to measure tool success rates, cost creep, and regressions without sending traces to a hosted platform.

evalharnesslocaltraces

toolGitHub

Vmette↗

chamuka-inc

Hardware-isolated microVM sandbox aimed at local AI agents on macOS, recently shown on HN for safe full-permission runs.

Use caseUse it to run agents with root-like freedom inside a guest while the host stays untouched.

microvmmacossandboxlocal

repoGitHub

GraphMemory↗

bradAGI

Embedded hybrid graph and vector database for GraphRAG pipelines powered by DuckDB.

Use caseUse it to give agents hybrid search, graph traversal, and context assembly in a single Python package.

memorygraphragduckdb

repoGitHub

KumaBox↗

kgpp34

Lightweight Cloud Hypervisor microVM sandbox runtime for agents and untrusted workloads.

Use caseUse it to script full VM lifecycle, snapshots, and guest execution from any agent tool call or CI job.

microvmcloud-hypervisorisolation

harnessGitHub

zeroshot↗

the-open-engine

Open-source orchestration engine that enforces review-repair graphs and workflow profiles over mixed coding agents.

Use caseUse it to define security-review gates and retry limits so small models match larger ones at lower cost.

orchestrationmeta-harnessreview-loops

harnessGitHub

nexent↗

ModelEngine-Group

Zero-code platform that auto-generates production-grade agents using harness engineering principles with unified tools, skills, memory, and control planes.

Use caseUse it to generate constrained agent systems with feedback loops and built-in orchestration without writing the loop from scratch.

harnesszero-codecontrol-plane

harnessGitHub

oh-my-hermes↗

rlaope

Packages that layer mixture-of-models routing, long-term project memory, priced cost telemetry, and native TUI surfaces onto Hermes Agent for coding and team workflows.

Use caseUse it to upgrade a Hermes base with subagent teams, memory packs, and live cost HUD without forking the core agent.

harnessmemoryskillstui

toolGitHub

QwenPaw↗

agentscope-ai

Personal AI assistant runtime with multi-chat-app support, extensible skills, MCP, and self-hosted or cloud deploy options.

Use caseUse it to deploy a personal super-agent that lives in chat apps and grows capabilities via skills.

toolpersonal-agentskillsmcp

harnessGitHub

SandBase Harness↗

sandbaseai

Local-first TypeScript runtime with persistent sessions, sandboxed tools, MCP, memory, credentials, audit logs, and replay.

Use caseUse it to own a self-hosted agent runtime with full audit and replay for long sessions.

harnesslocal-firstauditmcp

repoGitHub

agent-sdk-go↗

agenticenv

Durable execution framework for Go AI agents that keeps state, tool calls and loops resilient across crashes via durable-go or Temporal.

Use caseUse it to write crash-resilient Go agents that resume mid-tool-call without rebuilding session context.

godurablesdktemporal

repoGitHub

basically-ai-harness↗

TejasQ

Minimal TypeScript agent harness built branch-by-branch for a harness-engineering talk, covering eval versus agent loops.

Use caseUse it to clone and step through a from-scratch harness so you can fork the control flow patterns into your own loop.

typescriptharnesseducationalfrom-scratch

toolGitHub

Easy Agent↗

ConardLi

Readable layered terminal coding agent with permission rules, OS sandboxing, MCP, skills, sub-agents and multi-provider support.

Use caseUse it to run a production-style coding loop next to your repo with fail-closed sandbox and rewindable checkpoints.

terminalcoding-agentpermissionsmcp

harnessGitHub

eval-harness (nano-step)↗

nano-step

Typed evaluation for skills and agents with capability, regression and product checks plus provider-neutral evidence grading.

Use caseUse it to grade OpenCode skills or external runner evidence in CI without collapsing results into a single score.

evaltypedciskills

repoGitHub

Open Multi-Agent core examples↗

open-multi-agent

Runnable starter teams, PR-review and security agents that demonstrate OMA scheduler, checkpoints and offline dashboard.

Use caseUse it to scaffold a no-key local demo then swap in your providers for production multi-agent pipelines.

examplestypescriptmulti-agentscaffold

harnessGitHub

Agent Memory Control Plane↗

AlekseiUL

Local-first governance layer for agent memory with deterministic routing, ownership, review gates, scope-aware retrieval, and auditable receipts.

Use caseUse it to keep multi-agent memory from leaking preferences or silently overriding facts via SQLite and MCP tools.

memorygovernancemcplocal-first

toolGitHub

firecode↗

deadtrickster

Firecracker and libvirt sandboxes for coding agents with layered rootfs, 60ms checkpoint restores, a verify gate, and live run interaction.

Use caseUse it to run an agent with root inside a microVM, copy work out only after a host-side verify script passes.

firecrackercheckpointverifycli

harnessGitHub

Harness2↗

Google Research

Research framework for recursive agent harnessing that edits prompts, memory, skills, tools, and subagents via Propose-Probe-Compose while keeping model weights fixed.

Use caseUse it to run open-world harness optimization loops on JobBench, LAB, or WorkBuddy and accumulate an improvement library across tasks.

harness-engineeringrecursionevalresearch

repoGitHub

Memory Pod Fabric↗

amotivv-inc

Open protocol for AI memory infrastructure defining pods, capability tokens, Merkle-anchored audit trails, and Memory Card discovery.

Use caseUse it to standardize how agents store, retrieve, and share semantic memory across applications with verifiable receipts.

memoryprotocolauditmpf

harnessGitHub

NeMo Fabric↗

NVIDIA

Execution layer that gives apps and eval systems a consistent interface to compose, validate, and switch agent harnesses with normalized telemetry.

Use caseUse it to run the same consumer config against Claude Code, deepagents, OpenHands, or Pi adapters without rewriting integrations.

fabricadaptersevalnvidia

repoGitHub

sample-agentic-fabric↗

aws-samples

Reference Arbiter control plane on AWS that fabricates workers on demand, evaluates authority scopes, and records legibility for multi-agent systems.

Use caseUse it to prototype constitutional multi-agent coordination where every dispatch is governed and escalations become case law.

control-planeawsmulti-agentgovernance

harnessGitHub

AIagentOS↗

surya-koritala

Governed user-space Rust runtime and control plane for long-lived AI agents with lifecycle scheduling durable context tool authorization quotas and operator interfaces.

Use caseUse it to treat agents like OS processes with quotas authorization and durable state outside the model loop.

rustcontrol-planeruntimegovernance

harnessGitHub

Archon↗

coleam00

Workflow engine for AI coding agents with YAML-defined phases isolated worktrees and validation gates.

Use caseUse it to encode multi-phase coding workflows that spawn agents in worktrees and enforce gates before merge.

workflowworktreesvalidation

repoGitHub

Matt Pocock Skills↗

mattpocock

Composable engineering skills for coding agents covering alignment shared language ADRs specs tests and code review loops.

Use caseUse it to drop reusable skill files into agent contexts so they consistently produce ADRs tests and reviews.

skillscoding-agentsadrreview

repoGitHub

Neo4j Agent Memory↗

neo4j-labs

Graph-native memory system storing conversations knowledge graphs and reasoning traces backed by Neo4j with short-term long-term and reasoning memory plus MCP.

Use caseUse it to give agents durable entity-resolved memory with audit edges and eval harness that survives sessions across Python and TypeScript.

memorygraphneo4jmcp

repoGitHub

pve-microvm↗

rcarmo

Firecracker-like microVMs for Proxmox VE with KVM isolation under 200 ms boot supporting OCI images unikernels and agent workloads.

Use caseUse it to run coding agents as lightweight hardware-isolated VMs inside existing Proxmox homelab or bare-metal clusters.

microvmproxmoxkvmhomelab

repoGitHub

A-Mem↗

WujiangXu

Agentic memory system that dynamically organizes notes with Zettelkasten-style linking and continuous evolution.

Use caseUse it to let an agent itself decide how to index, link and refine long-term memories across sessions.

memoryagenticknowledge-graph

repoGitHub

Agent Diff↗

agent-diff-bench

Interactive sandboxes that replica third-party APIs (Slack, Linear, etc.) for deterministic agent evals and RL.

Use caseUse it to train or score agents against realistic API state changes without side effects or rate limits.

evalsandboxrlapi

repoGitHub

Meta-Agent↗

canvas-org

Continual harness optimizer that turns execution traces into prompt, tool and control-flow improvements without weight updates.

Use caseUse it to automatically evolve the scaffolding around a frozen model by evaluating candidate harness changes.

harnessmetaoptimization

harnessGitHub

Sandcastle↗

mattpocock

TypeScript library that orchestrates coding agents inside isolated sandboxes with configurable branch strategies and merge-back.

Use caseUse it to parallelize multiple AFK agents across Docker/Podman/Vercel sandboxes and automatically fold their commits.

harnessorchestrationtypescriptsandbox

repoGitHub

SPACE↗

Perplexity AI

Firecracker microVM sandbox platform with HTTP API, pause/resume, snapshots, and host-side credential and egress control.

Use caseUse it to give every agent task its own kernel-isolated Linux environment that boots in tens of milliseconds and never sees real secrets.

sandboxmicrovmfirecrackerisolation

toolGitHub

Stately Agent↗

statelyai

XState-powered agents where the state machine owns control flow and the model only proposes legal events.

Use caseUse it to make invalid agent actions impossible by encoding the entire loop as an inspectable, resumable state machine.

harnessstate-machinexstatedeterministic

harnesscrates.io / GitHub

ag-harness↗

ag-harness

Rust ADE utility for structured LLM turns with deny-by-default tools, durable sessions, and native sandboxed bash.

Use caseUse it to enforce typed, grant-gated agent turns with Seatbelt or Landlock isolation.

rustdeny-by-defaultsandboxsessions

toolGitHub

Graphicle↗

Graphicle-AI

Single Rust binary that builds a tree-sitter code graph plus project memory (docs, decisions, sessions) and serves cited excerpts over MCP within a token budget.

Use caseUse it to give any MCP coding agent precise file-and-line context instead of dumping whole files.

memorycode-graphmcplocal-first

toolGitHub

graphmemory↗

graph-memory

MCP server that indexes docs, code, and files into a semantic graph and exposes dozens of tools for search, knowledge, tasks, and skills.

Use caseUse it to give coding agents a shared project knowledge graph with REST and web UI.

memorygraphmcpindexing

harnessGitHub

harness-rs↗

liliang-cn

Rust framework that turns models into production agents with typed ReAct loops, staged autonomy levels, guards, and built-in observability.

Use caseUse it to build domain-specific agents with compile-time safety and progressive trust gates.

rustframeworkproductionguards

toolGitHub

MemoryGraph↗

memory-graph

Graph-DB MCP memory server for coding agents with relationship tracking, typed stores, and session briefing commands.

Use caseUse it to persist patterns, fixes, and decisions across agent sessions with explicit links.

memorygraphmcpcli

harnessGitHub

Polos↗

polos-dev

Open-source agent runtime with Docker or E2B sandboxes, durable workflows that resume mid-step, HITL approvals, Slack triggers, and OpenTelemetry tracing.

Use caseUse it to ship production agents that survive crashes and keep costs low via prompt caching.

runtimedurablesandboxobservability

harnessGitHub

Rivet Agents↗

rivet-dev

Durable actor runtime plus sandbox-agent server so coding agents run inside isolated boxes while the harness and memory live outside, controlled over HTTP/SSE.

Use caseUse it to keep the agent loop durable and auditable while tools execute in disposable sandboxes.

durableactorssandboxhttp

toolnpm/GitHub

agent-dev-env↗

community

Local sandbox VMs for coding agents with pre-built macOS, Windows ARM64, and Ubuntu images that share the work directory.

Use caseUse it to boot a full-toolchain guest VM on Apple Silicon that keeps your editor on the host while the agent works isolated.

local-vmmulti-oscoding-agent

toolGitHub

ags agent-sandbox↗

thomaspeklak

Rust CLI that launches Claude, Codex, Gemini, OpenCode, or Pi inside rootless Podman with lockdown and credential bridges.

Use caseUse it to keep host secrets off the agent while still mounting the repo and selected tools into a hardened container.

podmanrootlessrust-cli

toolGitHub

ai-jail↗

akitaonrails

Rust CLI that runs coding agents inside bubblewrap/Landlock/seccomp on Linux or sandbox-exec on macOS with private home and opt-in credentials.

Use caseUse it to prefix any agent command so the project is writable while host secrets and home stay hidden by default.

os-sandboxbubblewraplandlockcli

toolGitHub

Bromure↗

rderaison

macOS app that runs agentic coding and browsing inside disposable Linux VMs destroyed on window close, with host-side MITM credential proxy.

Use caseUse it to give Claude Code or Codex a throwaway Linux kernel where secrets never enter the guest.

macosvirtualization.frameworkcredential-proxyephemeral-vm

repoGitHub

BunkerVM↗

ashishgituser

Firecracker microVM sandbox with command recording, snapshot, restore, and step-level rewind for agent debugging.

Use caseUse it to time-travel an agent run by rewinding the microVM state after a bad command instead of replaying scripts.

firecrackertime-travelsnapshotmicrovm

toolGitHub

drydock↗

sricola

macOS Apple-container sandbox that runs agents in throwaway VMs, brokers short-lived tokens, and only returns approved git diffs.

Use caseUse it to submit unattended coding tasks whose only host-side output is a reviewable diff you must approve.

macosapple-containerdiff-gatecredential-broker

toolGitHub

Fence↗

Use-Tusk

Lightweight CLI sandbox that applies OS-native network and filesystem restrictions without a heavy runtime.

Use caseUse it to quickly constrain an agent process to approved paths and hosts before it touches the rest of the machine.

clios-nativefilesystemnetwork

toolGitHub

Landrun↗

Zouuup

Landlock-based sandboxing helper that applies kernel filesystem and network rules without requiring root.

Use caseUse it to drop unprivileged Landlock policies around agent-generated processes on modern Linux kernels.

landlockunprivilegedlinux

toolGitHub

nono↗

nolabs-ai

Zero-setup, zero-latency kernel sandbox using Landlock and Seatbelt that enforces least privilege without containers or VMs.

Use caseUse it to wrap Claude Code, Codex, or Pi with capability packs so filesystem and network access become structurally impossible outside the allowlist.

landlockseatbeltagent-sandboxzero-trust

toolGitHub

smolcoder↗

leonvanzyl

Lightweight coding harness for local open-weight models via Ollama or LM Studio with no API keys and no cloud.

Use caseUse it to turn a local Qwen or similar model into a file-editing, test-running coding agent on your machine.

local-llmcoding-harnessollama

toolGitHub

yolo-cage↗

borenstein

Restrictive sandbox that scans egress for secrets, blocks dangerous git operations, and isolates agents per branch.

Use caseUse it to let agents work autonomously while automatically stopping secret exfiltration and self-merge attempts.

egress-filtergit-guardrailsexfiltration-block

toolGitHub

yolobox↗

finbarr

Docker wrapper that mounts only the project directory at its real path so agents can YOLO without seeing the host home.

Use caseUse it to run any coding agent full-send inside a container while home, SSH keys, and secrets stay on the host.

dockeryolo-modeproject-isolation

harnessGitHub

adnanmasood/agent-fabric↗

adnanmasood

Enterprise-style agent harness control plane sample with planning, sandboxed execution, A2A delegation, approvals, memory, and budgets.

Use caseUse it as a cloneable reference to wrap an OpenAI Agents SDK loop with governance and FastMCP enterprise tools.

control-planeenterprisea2agovernance

toolGitHub

AgentDock↗

uvwt

Secure MCP runtime that lets agents operate local machines, servers, and containers under explicit permission boundaries.

Use caseUse it to give any chat agent controlled multi-device file, shell, Git, and browser access without model inference.

mcpruntimemulti-deviceself-hosted

repoGitHub

chrobakpiotr/agent-harness↗

chrobakpiotr

Reusable execution contract for spec-driven agents covering request/result documents, validators, recovery, and telemetry.

Use caseUse it to pin a shared offline-checked contract so multiple backends stay compatible on launch and cancel semantics.

contractspec-driventelemetrypython

harnessGitHub

Superserve↗

superserve-ai

Firecracker microVM infrastructure with long-running sessions, COW forks, credential broker, and TypeScript/Python SDKs.

Use caseUse it to give autonomous agents persistent isolated VMs that snapshot and fork without 24-hour kill limits.

firecrackersandboxsdkpersistent

harnessGitHub

Tarit↗

instavm

Rust-vmm based hypervisor plus multi-node orchestrator for ephemeral agent and RL sandboxes with warm pools and snapshots.

Use caseUse it to self-host a Firecracker alternative control plane with 35ms acquire times for bursty agent workloads.

hypervisormicrovmorchestratorrl

harnessGitHub

AgentENV↗

kvcache-ai

Distributed Firecracker platform for massive-scale agent environments with sub-50 ms snapshot resume and fork support.

Use caseUse it to run thousands of parallel agent rollouts or RL environments with cheap idle snapshots and on-demand image loading.

firecrackerdistributedrlsnapshot

repoGitHub

Arrakis↗

abshkbh

Self-hosted Cloud Hypervisor microVM platform with checkpoint-restore for agent code execution.

Use caseUse it to host long-running agent sessions that can snapshot and resume without losing filesystem state.

cloud-hypervisorcheckpointself-host

toolGitHub

BoxLite↗

boxlite-ai

Daemonless embeddable micro-VM runtime that runs OCI images inside hardware-isolated Boxes with secret brokering and egress allow-lists.

Use caseUse it to give any coding agent a persistent, kernel-isolated workspace that boots fast and never leaks host credentials.

microvmembeddableocisandbox

repoGitHub

delonix-runtime↗

angolardevops

Daemonless rootless-first Rust container and microVM runtime alternative to Docker/Podman.

Use caseUse it as a lightweight local runtime when agents need both OCI containers and microVM isolation without a daemon.

rustrootlessocimicrovm

repoGitHub

dicer↗

konradasb

Tool that slices bare-metal hosts into thousands of Firecracker or Cloud Hypervisor microVMs.

Use caseUse it to pack high-density agent sandboxes onto metal for cost-efficient parallel evaluation.

firecrackerdensitybare-metal

repoGitHub

Katakate k7↗

Katakate

Kata Containers plus Firecracker microVM stack packaged for K3s agent workloads.

Use caseUse it to run agent sandboxes as Kata/Firecracker pods on a lightweight Kubernetes cluster with allow-list egress.

katafirecrackerk8ssandbox

repoGitHub

lingcage↗

lingcage

Rust KVM VMM that cages agents inside cloned microVMs with multi-arch support.

Use caseUse it to boot once then clone per-sandbox microVMs for dense agent fleets on x86, aarch64 or riscv.

kvmclonerustvmm

harnessGitHub

mgit↗

hyper-swe

Sandboxed version control where agent work lands in per-task microVMs and only reviewed results reach main git.

Use caseUse it to let agents commit freely inside isolated VMs while your real repo stays clean until human accept.

gitmicrovmauditcoding

toolGitHub

nibrun↗

ilbertt

One-click Firecracker microVM hosting for single-binary apps with persistent disk and sleep/wake.

Use caseUse it to let an agent compile and deploy a tiny service binary into its own isolated microVM in one skill call.

firecrackerbinarydeploymicrovm

toolGitHub

Nimbus↗

AshishKumar4

Free unlimited POSIX sandboxes on Cloudflare Workers using WASM and Durable Objects.

Use caseUse it to give agents disposable POSIX environments at the edge without managing VMs yourself.

wasmcloudflareedgesandbox

repoGitHub

NVX↗

Microsoft Research / Azure Research

Ultra-light cross-platform micro-VM sandbox built on OpenVMM for untrusted agentic workloads with hardware isolation.

Use caseUse it to spin hardware-isolated Linux guests for agent code execution on KVM, MSHV or Windows Hypervisor Platform without a full hypervisor stack.

microvmresearchsandboxopenvmm

repoGitHub

OpenVMM↗

Microsoft

Modular cross-platform Rust VMM that underpins NVX and OpenHCL for lightweight guest isolation.

Use caseUse it to build or extend custom microVM runtimes when you need a clean Rust VMM base for agent sandboxes.

vmmrusthypervisorresearch

repoGitHub

SporeVM↗

sporevm

Forkable aarch64 (and experimental x86) Linux microVMs with fast save, restore, CoW fan-out and managed networking.

Use caseUse it to warm one parent VM then fork hundreds of agent children that share memory pages for parallel coding tasks.

microvmforksnapshotarm64

repoGitHub

Vibe↗

lynaghk

Lightweight microVM-oriented sandbox tooling aimed at secure agent code paths.

Use caseUse it to prototype hardware-isolated execution environments for untrusted LLM-generated scripts.

microvmsandboxsecurity

repoGitHub

Volant↗

0xchasercat

Experimental microVM runtime focused on agent isolation boundaries.

Use caseUse it to explore alternative VMM surfaces when standard Firecracker or libkrun paths are constrained.

microvmexperimentalisolation

harnessGitHub

Agnes Harness↗

AgnesAI-Labs

Pluggable agent harness designed for forward-deployed engineering with recoverable evidence-first execution.

Use caseUse it to run trustable agent workflows that produce auditable artifacts and can resume after failures.

harnessfdeevidence

repoGitHub

deepagents-sbx↗

restuhaqza

MicroVM backend for Deep Agents that runs every command inside a guest with its own Linux kernel and private Docker daemon.

Use caseUse it to give LangGraph Deep Agents hardware isolation so generated containers never share the host kernel.

microvmdeep-agentssandbox

harnessGitHub

mi↗

Minimal self-extending sandboxed agentic harness consisting of a loop, two tools and an LLM that hot-loads new tools from .mjs files.

Use caseUse it to bootstrap a coding agent that can extend its own toolset while running inside an optional Docker sandbox.

harnessminimalsandboxself-extending

toolGitHub

mvm↗

agentstep

Hardware-isolated Linux VMs that boot in 0.35 s on Apple Silicon and the same binary on Linux Firecracker hosts.

Use caseUse it to provide coding agents native microVMs on macOS that pause to zero CPU and restore with disk rollback.

microvmmacosfirecracker

repoGitHub

Sandcastle↗

various

TypeScript library for orchestrating coding agents inside isolated sandboxes with configurable branch strategies.

Use caseUse it to spin parallel agent worktrees that stay isolated until a merge decision is made.

sandboxtypescriptorchestration

harnessnpm

@ai-sdk/harness↗

Vercel AI SDK

Experimental HarnessAgent plus sandbox session interfaces for network-aware agent loops in the AI SDK.

Use caseUse it to bootstrap typed harness sessions with Vercel or E2B sandboxes and schema-backed outputs.

sdkharnesstypescriptsandbox

toolGitHub Marketplace

Agent Security Harness↗

msaleme

CI action that runs protocol-level adversarial tests against MCP/A2A endpoints with PASS/FAIL/INCONCLUSIVE verdicts.

Use caseUse it as a gate to probe live agent endpoints for policy violations without false PASS on unreachable targets.

securityevalcimcp

repoGitHub

e2b-dev/ai-sdk-sandbox↗

e2b-dev

E2B sandbox backend for Vercel AI SDK so HarnessAgent code runs inside microVMs.

Use caseUse it to wire E2B sessions into AI SDK tools and harnesses with restricted surfaces.

e2bai-sdksandbox

repoGitHub

Gondolin↗

earendil-works

Local Linux micro-VMs with a TypeScript control plane for programmable network, filesystem, and secret injection policies.

Use caseUse it to wrap agent tool calls in disposable QEMU or krun VMs while keeping credentials and egress on the host.

microvmsandboxtypescriptcontrol-plane

harnessGitHub

Mecatl↗

stacklok

Cloud-native open-source agent harness with provider-agnostic loop, durable state, permissions, gRPC/HTTP APIs, and optional local microVM execution.

Use caseUse it to run the same agent loop locally or on Kubernetes with Redis-backed sessions and deny-dominant permissions.

harnesskubernetescloud-nativepermissions

toolOrigins AI / product

Prime Sandboxes↗

Prime Intellect

Hardware-isolated Linux microVMs for agentic RL at scale with large immutable environment catalog and high concurrency.

Use caseUse it to train or evaluate agents against reproducible microVM environments at thousands of concurrent instances.

microvmrlevalcatalog

repoGitHub

RyanAlberts comparisons↗

RyanAlberts

Category-ranked top harnesses regenerated weekly from live star and capability data.

Use caseUse it to shortlist progressive-disclosure, coding, or research harnesses by current metrics.

rankingcomparisonharness

repoGitHub

zerocore-ai/microsandbox↗

zerocore-ai

Open-source local-first hardware-isolated sandboxes with instant startup and OCI compatibility for agent workloads.

Use caseUse it as an embeddable microVM backbone for untrusted code execution in agent pipelines.

microvmlocaloci

harnessGitHub

ABox↗

AdminTurnedDevOps

Experimental microVM-native zero-trust local agent harness with semantic authorization and host TUI/SDK on Apple Silicon.

Use caseUse it to keep prompts tools and model calls inside a libkrun guest while the host only brokers approvals.

microvmzero-trustlocalharness

harnessGitHub

agent-eval-harness↗

sebuzdugan

Tiny reproducible eval harness proving per-task microVM isolation is required to stop agents from cheating benchmarks.

Use caseUse it to run held-out verification on Tensorlake Firecracker sandboxes so scores cannot be gamed by the agent.

evalharnessisolationmicrovm

toolGitHub

Archkeel↗

rapiddweller

Deterministic architecture boundary checker for agent-written code that reports forbidden imports and evidence without an LLM.

Use caseUse it to gate agent PRs with static architecture contracts that stay visible as PASS FAIL or UNKNOWN.

architectureguardrailsdeterministicci

harnessGitHub

elizaOS↗

elizaOS

Open-source agentic operating system with core runtime, plugins, local inference, native bridges, and multi-surface apps.

Use caseUse it to stand up a full plugin-extensible agent OS that owns memory actions connectors and device bridges.

agent-osruntimepluginstypescript

harnessGitHub

Orchard↗

microsoft

Kubernetes-native agentic modeling framework that decouples Orchard Env sandboxes from any training or harness loop.

Use caseUse it to share one cheap sandbox substrate across SFT RL and multiple coding harnesses on spot clusters.

kubernetessandboxrltraining

harnessGitHub

pi-herdsman↗

boadij

Orchestration layer that turns Pi sessions into coordinated fleets with nested delegation background work and herdr supervision.

Use caseUse it to fan parallel Pi coding agents across worktrees while a supervisor owns ownership and handoff.

orchestrationpimulti-agentworktree

toolGitHub

smol-pi↗

neuroblaze

Shell utility that runs the Pi coding agent inside ephemeral smolvm microVMs with scoped mounts and egress modes.

Use caseUse it to confine Pi to a disposable kernel so home keys and host processes stay unreachable.

pismolvmsandboxcli

harnessGitHub

ANOLISA↗

community

Agentic OS with runtime, security, observability and tokenless compression for lower cost long-horizon agents.

Use caseUse it to run agents under an OS-like layer that compresses context and enforces runtime security without extra tokens.

agentic-osruntimesecurityobservability

toolGitHub

CreateOS Sandbox SDK↗

NodeOps-app

TypeScript SDK for CreateOS microVM sandboxes with pause-to-snapshot, fork branching, private networking and typed errors.

Use caseUse it to launch stateful agent sandboxes, expose ports, manage disks and fork parallel branches from a golden snapshot.

sdkmicrovmtypescriptfork

toolGitHub

Matchlock↗

jingkaihe

CLI for ephemeral Firecracker/Virtualization.framework microVMs with network allowlisting and host-side MITM secret injection.

Use caseUse it to run any coding agent in a disposable Linux VM where API keys stay on the host and only allowed hosts are reachable.

microvmfirecrackersecretscli

harnessGitHub

OpenAgentCore↗

MiniMax-AI

Self-hosted open implementation of the OpenAI Agents API with multiple native harnesses and sandbox support.

Use caseUse it to run Agents API compatible sessions on your own infrastructure with pluggable harnesses and sandboxes.

agents-apiself-hostedharnesssandbox

toolGitHub

Strands Box↗

strands-agents / AWS

OS-isolation sandbox with default-deny Dogwood semantic policies, credential injection, and event-history aware rules for any agent harness.

Use caseUse it to confine any coding agent on macOS Apple silicon under temporal and argument-aware policies without secrets entering the box.

sandboxpolicydogwoodmacos

toolGitHub

agent-house↗

mariobm

Self-hostable stateful Linux microVMs for coding agents with client on Mac/Linux and server-side isolation plus snapshots.

Use caseUse it to give agents persistent interactive shells and files on hardware you control without public ports.

microvmself-hostpersistentsnapshots

repoGitHub

Agentic Harness Engineering↗

yzs-lab

Observability-driven system that automatically evolves coding-agent harness components while holding the base model fixed, lifting Terminal-Bench scores.

Use caseUse it to run evaluate-analyze-improve loops that produce transferable frozen harnesses for SWE-bench and other models.

evolutionobservabilityevalmeta-harness

repoGitHub

Kuasar Sandbox↗

kuasar-sandbox

Production microVM platform with independent guest kernels, snapshot templates, pause/resume, on-demand loading and single-to-cluster deployment for agents and RL.

Use caseUse it to run high-density agent or serverless workloads with KVM isolation and stateful lifecycle control.

microvmhigh-densityrlcluster

repoGitHub

Agent Sandbox (SheerWill)↗

SheerWill007

Firecracker microVM sandbox with MCP, TypeScript SDK, jailer isolation and network namespaces.

Use caseUse it to run agent code in hardware-isolated VMs with native MCP tool surface on your infra.

FirecrackerMCPmicroVMself-host

harnessGitHub

ai-agent-eval-harness (AgentV)↗

najeed

MultiAgentOps verification OS and evaluation harness with industrial scenarios, mutation testing and tool sandbox.

Use caseUse it to verify enterprise agent workflows across thousands of industry scenarios before production.

evalverificationharnessenterprise

toolGitHub

kagent↗

kagent-dev

Kubernetes-native agent platform with sandbox workflows, templates and group agent commands.

Use caseUse it to discover and run agents plus standalone sandboxes under one CLI on a cluster.

kubernetessandboxCLIagent

repoGitHub

microvm (0xthierry)↗

0xthierry

Local Firecracker microVM tool for running isolated coding agents and dev workloads from Dockerfiles.

Use caseUse it to give any CLI coding agent a real VM boundary on your laptop with persistent disks and controlled networking.

FirecrackerlocalmicroVMisolation

repoGitHub

agentic-harness (skills)↗

codejunkie99

File-based drop-in operating system of skills and workflows for any file-aware coding agent across SaaS, CLI, MCP, and mobile.

Use caseUse it to give Claude Code or similar agents a durable spec-to-release cycle with verification gates.

skillsworkflowfile-based

toolGitHub

Assay↗

awss1i

Deterministic QA CLI that drives web pages with Playwright to find self-contradictions without needing written tests or an LLM.

Use caseUse it as a post-edit stop hook inside any coding harness to catch UI bugs cheaply.

qaevalplaywright

toolGitHub

Cordum Edge↗

cordum-io

Local firewall and sandbox layer that contains AI coding agents with policy enforcement outside the model.

Use caseUse it to wrap any coding agent so destructive actions hit a local policy gate first.

firewallsandboxpolicy

harnessGitHub

ECC↗

affaan-m

Cross-harness operating system of skills, rules, hooks, and MCP conventions that works across multiple coding agents.

Use caseUse it to install a shared skill pack and control pane so Claude Code, Codex, and others share the same workflows.

skillscross-harnessos

toolfreestyle.sh

Freestyle↗

Freestyle

Cloud sandboxes purpose-built for coding agents with full Linux, hardware virtualization, fast starts, and memory-level forking.

Use caseUse it to give agents EC2-like environments that fork in under 400 ms while preserving running state.

sandboxvmfork

toolGitHub

Kern↗

getkern

Daemonless rootless container runtime and sandbox that starts real OCI boxes in a few milliseconds for agent tool calls and LLM-generated code, with MCP bindings.

Use caseUse it to execute untrusted agent code in kernel-enforced namespaces and cgroups with zero resident memory when idle.

sandboxcontainermcpdaemonless

harnessGitHub

OpenCode Harness↗

samarailly51-pixel

Clean-room model-agnostic harness that standardizes task execution, tool calling, traces, and evaluation reports for coding agents.

Use caseUse it to run and benchmark Claude Code-class agents across providers with consistent eval output.

clean-roomevalharness

repoGitHub

Ponytail↗

DietrichGebert

Skill pack that forces coding agents into lazy-senior-dev mode (YAGNI, reuse, minimal code) across multiple harnesses.

Use caseUse it to inject a consistent minimalism policy into DeepSeek Harness or other plugin hosts.

skillsstyleminimal

harnessrelayevals.com

Relay↗

rsathwik07

Recovery-and-verify harness that loops coding agents on failing checks inside fresh sandboxes until tests pass, then opens a clean PR.

Use caseUse it to turn flaky agent runs into reliable diffs by retaining failure lessons across retries.

recoveryverifysandbox

harnessGitHub

Agent Lightning↗

Microsoft

Training-oriented harness with optimization loops over agent rollouts for policy improvement rather than one-shot scoring.

Use caseUse it to close the loop from agent trajectories back into better behavior via APO-style training.

trainingevalsoptimizationmicrosoft

repoGitHub

AgentVM↗

deepclause

Lightweight Node.js WASM-based Alpine Linux VM for agents with shell, networking, firewall and persistence for isolated command execution.

Use caseUse it to run agent shell commands inside a worker-thread Linux VM with DHCP, port forwards and snapshottable state.

wasmlinux-vmsandboxnodejs

toolGitHub

Autobox↗

freakynit

Low-friction sandbox that attaches per-tool permissions and instant clonefile repo copies so agents can destroy a writable tree then sync back.

Use caseUse it on M-series Macs to let hesitant teams get best-effort isolation without full VM setup friction.

sandboxpermissionsclonefilemacos

harnessGitHub

Castor↗

castor-ai / claytonia et al.

Secure execution layer that turns every agent tool call into a kernel syscall with budgets, immutable journals, and suspend/resume.

Use caseUse it to bound agent power with structural budgets and pause/resume without replaying costly early steps.

execution-layersyscallbudgetjournal

repoGitHub

CLI-Anything↗

HKUDS

Hub and harnesses that wrap existing CLI software into agent-native interfaces with per-app agent-harness modules and plugins.

Use caseUse it to expose Blender, GIMP, Ollama, n8n or dozens of other tools as structured agent skills without rewriting the apps.

cliagent-nativeskillsharness

harnessGitHub

Harbor↗

various / Terminal-Bench related

Generalized harness for evaluating and improving agents at scale, paired with terminal benchmarks.

Use caseUse it to run large-scale agent rollouts against Terminal-Bench style tasks with consistent isolation and scoring.

eval-harnessterminal-benchscaleimprovement

harnessGitHub

LoopX↗

loopx-project

Local-first control plane with durable state kernel for long-horizon agents and teams, goals, evidence, heartbeats, and cross-runtime handoffs.

Use caseUse it to keep multi-day coding or research goals alive across sessions with claims, leases, reward memory, and recoverable peer ownership.

control-planelong-horizondurable-stateheartbeat

toolGitHub

Mitos↗

snapshot-fork microVM projects

Snapshot-fork microVM sandboxes that give agent sessions clean isolated starting states with declarative lifecycle and parallel execution.

Use caseUse it to fork agent sandboxes from snapshots so each trial starts clean and can run in parallel without shared state.

microvmsnapshotforksandbox

harnessGitHub

Paperclip↗

paperclipai

Open-source app and server for managing teams of AI agents at work with org charts, budgets, goals, adapters, and cost tracking.

Use caseUse it to hire heterogeneous agents as employees, assign company goals, and track handoffs and spend from one dashboard.

orchestrationmulti-agentgovernancedashboard

harnessGitHub

AgentRun↗

Parcha-ai

Open DSL and runtime that converts agent traces into reusable workflows mixing tools, code, Jev decisions and agent steps.

Use caseUse it to extract repeatable agent work into inspectable workflows that avoid full loops where code or decisions suffice.

dslworkflowjevpi

toolGitHub

deja-vu↗

vshulcz

Accurate low-cost memory layer that indexes searchable session history across 32-plus coding agent harnesses.

Use caseUse it to give agents persistent recall of prior Claude Code, Codex or Cursor sessions through MCP.

memorysessionmcphistory

toolGitHub

gentle-ai↗

Gentleman-Programming

Configuration layer that standardizes persistent memory and tooling across the coding agents you already run.

Use caseUse it to apply shared memory and setup patterns to Claude Code, Cursor, OpenCode, Codex and Pi in one place.

configmulti-harnessmemory

toolGitHub

Jauvex↗

reindent

Desktop app for side-by-side voice and text control of multiple coding agents with Kanban workflows and self-development.

Use caseUse it to orchestrate Claude, Codex and Grok sessions into automated voice-driven routines that the app can update itself.

voicemulti-agentdesktopworkflow

harnessGitHub

Sandbank↗

chekusu

Unified workspace harness that keeps agent identity, memory and artifacts while scheduling across multiple sandbox backends.

Use caseUse it to materialize a persistent Workspace protocol then dispatch tasks to E2B, cloud or local runtimes as needed.

workspacemulti-backendharness

repoGitHub

trpc-agent-go↗

trpc-group

Go framework for production agent systems featuring graph workflows, tools, memory, A2A, MCP, eval and observability.

Use caseUse it to build multi-agent systems in Go with full production primitives for workflows and evaluation.

goframeworkmulti-agentmcp

harnessGitHub

Yuxi↗

xerrors

Agent harness that integrates LightRAG knowledge bases and knowledge graphs on LangChain with MCP support.

Use caseUse it to build agents that reason over structured RAG and graphs while exposing tools via MCP.

ragknowledge-graphlangchainmcp

repoGitHub

Agent Substrate Env↗

agent-substrate

Environment abstraction on Substrate providing remote cmd, filesystem and built-in MCP tools inside isolated actors.

Use caseUse it to give agents a stable remote environment API while Substrate handles multiplexing and snapshots underneath.

environmentmcpkubernetesactor

harnessGitHub

Agentplane↗

basilisk-labs

Git-native control plane that keeps authority, plans, verification and evidence in the repo while agents do the judgment work.

Use caseUse it to bound coding-agent authority, advance lifecycle state and produce reviewable PR evidence without hiding state.

control-planegitverificationcli

toolGitHub

ArcBox↗

arcboxlabs

Pure-Rust macOS runtime offering Docker drop-in, nested Firecracker sandboxes for agents, full Linux/macOS VMs, and sub-200ms boots.

Use caseUse it to run coding agents inside disposable microVMs on Apple Silicon with the same API as cloud sandboxes.

microvmsandboxmacosrust

toolGitHub

Cleanroom↗

buildkite

Policy-to-microVM compiler that bakes warm spores with deps installed, provenance and deny-by-default network for repo workloads.

Use caseUse it to turn cleanroom.yaml into reproducible agent sandboxes that fork from hot snapshots for CI or local runs.

microvmpolicycisnapshot

repoGitHub

forkd↗

deeplethe

KVM microVM fork engine that spawns 100 CoW children from a warm parent in ~100ms for agent tree search or RL.

Use caseUse it to branch live agent environments for parallel exploration without cold boots or full image reloads.

microvmforkkvmsnapshot

toolGitHub

FrontierAgent↗

ApodexAI

Open-source agent runtime and TUI with native ReAct and Agent Team modes, task-scoped sandboxes and separate eval harness.

Use caseUse it to run long-horizon research or coding workflows with parallel sub-agents and fail-closed file/shell isolation.

tuimulti-agentsandboxeval

harnessGitHub

GatewayStack↗

agentic-control-plane

Open-core TypeScript modules for identity, policy, rate limits, routing, PII redaction and audit on every agent tool call.

Use caseUse it to insert a control plane that policy-checks tool invocations before any coding agent or MCP server runs them.

control-planepolicytypescriptmcp

toolGitHub

Hindsight↗

vectorize-io

Agent memory system that learns from experience and improves over time with long-term retention for multi-session loops.

Use caseUse it to attach a learning memory layer so agents retain and refine skills across coding or research runs.

memorylearningagent

harnessGitHub

openharness↗

autonomous-ai

Command-center harness that runs multiple coding agents and craft-specific tools side-by-side across local and remote machines.

Use caseUse it to orchestrate code plus CAD, circuits or music agents from one board with per-craft harness.json definitions.

multi-agentorchestrationtui

toolGitHub

OpenShell↗

NVIDIA

Policy-governed runtime that instruments kernel access, enforces filesystem/network/process rules and keeps credentials outside agent sandboxes.

Use caseUse it to wrap any coding agent in declarative allow/deny policies with formal verification before applying changes.

runtimepolicysandboxsecurity

toolGitHub

Vetto↗

shleder

Daemon-less rootless kernel sandbox that injects immutable boundaries between fork and execve with sub-4ms latency for coding CLIs.

Use caseUse it to shim Claude Code, Codex or Aider so every spawn is Landlock/cgroup constrained without Docker overhead.

kernelsandboxlandlockcli

harnessGitHub

Agent Eval Harness↗

sn0bored

Vendor-neutral regression harness for agents and LLM-as-judge workflows with JSONL cases, deterministic graders, and CI fail-on-regress.

Use caseUse it to version conversation cases and fail CI when an agent policy or tool-selection drifts.

evalsregressionllm-as-judgeci

harnessGitHub

AgentOS (framerslab)↗

framerslab

TypeScript agent framework with cognitive memory, runtime tool forging, multi-agent orchestration, and strong LongMemEval numbers.

Use caseUse it to build agents that remember across sessions and forge their own tools under multi-provider dispatch.

typescriptmemorytool-forgingmulti-agent

toolGitHub

CodeWhale↗

Hmbown

Open-source Rust terminal coding agent harness with TUI, multi-provider support, and community-driven loop design.

Use caseUse it to drive a fast local coding loop from the terminal when you want a systems-language harness instead of a Node TUI.

rusttuicoding-agentcli

repoGitHub

openshell-deepagent↗

LangChain + NVIDIA

Coding agent that runs inside NVIDIA OpenShell policy sandbox, orchestrated by Deep Agents and Nemotron.

Use caseUse it to execute agent-written code under external filesystem and network policies without cloud sandboxes.

openshellnvidiapolicydeepagents

harnessGitHub

QM↗

yc-software

Multiplayer organizational agent harness with per-person and per-room scopes, durable sandboxes, memory, permissions, and swappable coding runtimes.

Use caseUse it to give a team scoped agent rooms with Postgres-backed sessions and policy-controlled sandboxes.

multiplayerorgsandboxpolicy

harnessGitHub

RLMAgents↗

Hmbown

Recursive Language Model style agent harness built on Deep Agents with persistent REPL control and practical tooling.

Use caseUse it to treat prompts and subagents as programmatic variables inside a recursive coding loop.

rlmrecursivedeepagentsharness

repoGitHub

vm-price-board↗

sf-tools

Live comparison of agent sandbox and microVM pricing across providers with free-tier visibility.

Use caseUse it to pick the cheapest Firecracker or gVisor sandbox shape before locking an agent fleet budget.

pricingsandboxmicrovmcomparison

toolGitHub

agent_sandbox (HPC)↗

katosh

Kernel-enforced credential and network jail for untrusted Linux processes with Slurm awareness and built-in agent profiles.

Use caseUse it to wrap coding agents on HPC login nodes so sbatch and credentials stay sandboxed without containers.

hpcslurmjailcredentials

toolGitHub

agent-sandbox-os↗

dhanababum

Easy microVM sandboxes for AI agents and untrusted code on AWS Lambda MicroVMs with Python SDK, asb CLI, and MCP server.

Use caseUse it to boot a Firecracker sandbox in seconds, exec agent code, forward ports, and suspend/resume long sessions without managing clusters.

microvmlambdafirecrackermcp

repoGitHub

open-harness (SDK)↗

MaxGfeller

Code-first composable SDK built on Vercel AI SDK for powerful AI agents with sessions, middleware, VFS providers, and React/Vue hooks.

Use caseUse it to wire Agent plus createFsTools and createBashTool for sandboxed file and shell access inside your own product UI.

sdkvercel-aicomposablevfs

repoGitHub

serverless-runtime / agent-sandbox↗

vivek1504

Firecracker microVM sandboxing for AI agents with millisecond boots from snapshots, full network, and native MCP support.

Use caseUse it to give each agent session a dedicated hardware-isolated Linux machine that restores in under 100 ms end-to-end.

firecrackermicrovmmcpsnapshot

repoGitHub

awesome-agent-harness↗

Picrew

Implementation-first awesome list of agent harness engineering projects, tools, benchmarks, and guides with hundreds of GitHub entries.

Use caseUse it to discover obscure sandbox and harness layers mapped to execution, tooling, lifecycle, and governance needs.

awesome-listharnesssandboxengineering

harnessHacker News / project

Castor↗

Castor authors

Secure execution layer that treats every tool call as a syscall through a microkernel with budgets, immutable journal, pause, and resume.

Use caseUse it to enforce hard capability limits and budget-based approvals so agents cannot bypass structural gates.

microkernelsyscallbudgetsecurity

repoGitHub

cocoon sandbox↗

cocoonstack

Fast cold-boot MicroVM sandboxes with warm pools, in-guest daemon, and Go/Python SDKs built on the cocoon stack.

Use caseUse it to claim sub-millisecond warm sandboxes or tens-of-ms golden clones for agent code execution.

microvmwarm-poolsdkagent

harnessHacker News

Recurse↗

Recurse team

Serverless agent harness plus coding-agent skill that iterates prompt and tool variants against verifiable domains with an FSM refinement loop.

Use caseUse it to auto-generate and evaluate specialist agents when you can define a clear input/output contract and eval.

serverlessevalfsmspecialist

harnessGitHub / product

Canary verification↗

runcanary

Independent verification harness that takes agent changesets, spawns swarms in sandboxes, and returns evidence of failures.

Use caseUse it to pressure-test coding-agent patches with runtime scenarios before you accept the claim of done.

verificationswarmsandboxevidence

toolGitHub

Harness.apk↗

nev3rfail

On-device Android agent harness that runs the full loop locally with phone sensors, Maps, browser debugging, and widgets.

Use caseUse it to keep an always-on agent in your pocket that can act on photos, maps, and local apps without a remote host.

androidon-devicemobilelocal

harnessGitHub

Unreal Agent↗

unreallabsai

Async-first agent harness focused on non-blocking loops and concurrent tool execution for high-throughput agent systems.

Use caseUse it to build agents that schedule many concurrent tool calls without blocking the main reasoning turn.

asyncharnessconcurrency

harnessGitHub

AerolVM↗

aerol-ai

Single-binary self-hosted sandbox platform supporting containerd, gVisor, Firecracker, WASM and V8 isolates with Raft clustering.

Use caseUse it to stand up multi-runtime agent sandboxes on one Linux host or a HA cluster with E2B and Daytona API facades.

multi-runtimeself-hostedclusteregress-control

harnessGitHub

Agent Memory Leaderboard↗

AML-memory

Open reproducible eval platform and challenge for long-term agent memory systems across textual and coding tracks.

Use caseUse it to benchmark your memory graph or store against standardized LongMemEval-style tasks before production.

evalmemoryleaderboardreproducible

harnessGitHub

Dormice↗

BitMiracle-AI

Self-hosted E2B-compatible sandbox platform where sandboxes are permanent, idle freezes cost almost nothing, and one key always returns the same box.

Use caseUse it to give every agent a durable, freezeable sandbox on hardware you already own instead of paying per-second cloud boxes.

e2b-compatiblepermanentgvisorsqlite

repoGitHub

E2B Runtime↗

e2b-dev

Open-source Firecracker control plane, orchestrator and guest agent that powers E2B sandboxes, runnable on your own hardware.

Use caseUse it to self-host the exact microVM runtime behind E2B so agent code execution stays inside your boundary.

firecrackerself-hostcontrol-planeopen-runtime

toolGitHub

smolvm↗

smol-machines

Embeddable portable microVM that boots under 200 ms via Hypervisor.framework or KVM, packs into a single file, and supports OCI images.

Use caseUse it to run local agent code in hardware-isolated VMs with elastic memory and opt-in networking without a Docker daemon.

portablelibkrunlocal-firstoci

toolGitHub

Zeroboot↗

zerobootdev

Sub-millisecond KVM sandboxes for agents via copy-on-write Firecracker snapshot forking with tiny memory footprints.

Use caseUse it to spawn hundreds of hardware-isolated Python or shell sandboxes in under a millisecond for parallel agent tool calls.

firecrackercowmicrovmlow-latency

harnessGitHub

Agent Harness (JakeSelby)↗

JakeSelby

Control plane that projects one checkout of rules, skills, hooks, and stances into multiple coding agents with telemetry and ownership journals.

Use caseUse it to enforce guardrails and cost postures once across different agent CLIs without rewriting each integration.

control-planehookstelemetryrules

toolGitHub

Agent-Native↗

BuilderIO

TypeScript framework for agentic apps where every capability is a shared action callable by both the agent as a tool and the UI from code, with live sync and templates.

Use caseUse it to scaffold an app whose agent and React UI share the same validated actions, auth, and state without dual implementation.

typescriptuiactionsframework

harnessGitHub

Agentgateway↗

agentgateway

Open-source proxy for agent-to-LLM, agent-to-tool, and agent-to-agent traffic with MCP and A2A support, guardrails, RBAC, and inference routing.

Use caseUse it as the drop-in connectivity layer that federates MCP tools and enforces budgets and policies across frameworks.

proxymcpa2aguardrails

harnessGitHub

Agentrail↗

yai-dev

Composable open-source harness with runtime core, hosted server layer, prompt SDK, multi-agent mailboxing, filesystem memory, and Docker sandbox isolation.

Use caseUse it to define production agents in code with streaming lifecycle, sub-agent recovery, and no platform lock-in.

typescriptorchestrationsandboxmulti-agent

harnessGitHub

macher-agent↗

elij

Emacs-native LLM agent harness with isolated sandboxing, asynchronous sub-agent orchestration, and fail-fast sync file merging inside buffers.

Use caseUse it to run concurrent multi-agent workflows entirely inside Emacs with Lisp callbacks and secure code execution.

emacsmulti-agentsandboxlisp

harnessGitHub

Nasiko↗

Nasiko-Labs

Rust developer control plane that deploys, routes, secures, and observes any A2A-speaking agent behind a single ingress with MCP gateway and LLM router.

Use caseUse it to run a multi-language agent fleet where every hop is authenticated, rate-limited, and traced without exposing agents publicly.

rusta2acontrol-planemcp

toolGitHub

Pi Coding Agent↗

earendil-works

Minimal extensible terminal coding harness with unified multi-provider API, TUI, skills, MCP, and tree-structured sessions.

Use caseUse it as a lightweight TUI agent loop you can extend with TypeScript plugins without a heavy product shell.

tuimcpskillsprovider-agnostic

repoGitHub

Strands Evals↗

strands-agents

Evaluation framework for agents covering trajectory checks, LLM-as-judge, chaos and corruption effects, skill-level scoring, and multi-provider mappers.

Use caseUse it to score agent behavior and tool selection with repeatable suites before shipping a harness change.

evalspythontrajectoryjudge

toolGitHub

Strands Shell↗

strands-agents

In-process Bourne-compatible shell for agents with VFS, 50-plus commands, URL allowlists, and secret injection that never forks or exposes host credentials.

Use caseUse it to give coding agents grep, sed, jq, and curl in under 1 ms cold start without Docker or microVMs.

rustshellvfsisolation

repoGitHub

that-agent↗

that-labs

Kubernetes-native Rust agent that receives a compiler and a namespace so it can author, build, and deploy its own tools and services at runtime.

Use caseUse it to let an agent extend its own capability surface with sandboxed pods, BuildKit, and an LLM-judge eval harness.

rustkubernetesself-extendingsandbox

toolGitHub

Agent Safehouse↗

eugene1g

macOS sandbox-exec wrapper that applies deny-first composable profiles so coding agents can only touch the files and tools they need.

Use caseUse it to wrap any local agent CLI so it cannot read SSH keys or shell configs while still working in the project directory.

macossandboxpolicycli

harnessGitHub

agent-harness (0xenzyme)↗

0xenzyme

Adapter-driven control plane that turns roadmaps into goals, tasks, run DAGs, gates, verification, and state sync for coding agents.

Use caseUse it to let a host agent drive scoped execution and evidence collection without routing every step manually.

control-planedagverificationadapter

repoGitHub

agent-sandbox-runtime↗

ixchio

Self-correcting Docker-sandboxed runtime that generates, executes, catches errors, and iterates until the task passes.

Use caseUse it to run generate-execute-repair loops inside locked containers for code tasks.

dockerself-correctpythonloop

harnessGitHub

AgentHarness↗

alexzhu0

Pre-execution evidence control-plane that makes agent actions policy-driven, testable, and auditable before they hit external runtimes.

Use caseUse it to gate tool calls with evidence contracts and keep execution outside the control plane.

control-planepolicyauditevidence

repoGitHub

cocoon↗

cocoonstack

Lightweight MicroVM engine on Cloud Hypervisor with instant snapshot/clone, OCI support, and Docker-like CLI for AI sandboxes.

Use caseUse it to spawn CoW-forked VMs for ephemeral agent environments with low memory overhead.

microvmsnapshotkvmsandbox

toolGitHub

Drop↗

community

Rootless Linux sandbox with gVisor support for running untrusted apps safely without full virtualization overhead.

Use caseUse it to contain agent-generated processes under gVisor on a developer machine.

gvisorrootlesslinuxsandbox

toolGitHub

NiftyAgent↗

trevordev

Single-file Node agent CLI under 500 LOC with no framework dependencies for rapid architecture experiments.

Use caseUse it as a baseline loop to prototype context or completion strategies without scaffolding weight.

minimalnodejscliexperiment

toolGitHub

san↗

genai-io

Lean open-source terminal agent runtime in a single Go binary with native speed and full openness.

Use caseUse it to run a minimal provider-agnostic coding loop from one static binary.

gocliterminallean

harnessGitHub

software-factory↗

stratonext

Local YAML-driven factory that queues coding agents in isolated Git worktrees with plan/code/test/review pipelines.

Use caseUse it to parallelize multiple features from one driver agent without worktree conflicts.

worktreepipelinelocalyaml

harnessGitHub

Sokit↗

jodan-alberts

LangChain-like harness for System-1 models such as Jev, focused on tool calls and iterative solving.

Use caseUse it to wire simple iterative tool loops around fast decision models.

system-1toolspythonharness

toolGitHub

aeon↗

aeonfun

Autonomous agent framework that runs unattended on GitHub Actions with self-healing skills and drives multiple coding agents.

Use caseUse it to configure once and let agents ship PRs on a schedule with no human approval loops.

github-actionsautonomousself-healingdevops

repoGitHub

agent-harness layers↗

paolo-perrone

Educational five-layer agent harness (execution boundary, sandbox, memory, verification, context) that runs with a scripted model and no API key.

Use caseUse it to understand and copy the exact failure modes each harness layer prevents before wiring them into production.

educationlayerspythonminimal

harnessGitHub

AX↗

Google / rakyll et al.

Declarative high-throughput orchestrator for agentic tasks that uses Workspace, Gateway, Task and Model primitives on top of Agent Substrate and Kubernetes.

Use caseUse it to apply YAML manifests that spin up sandboxed agent workloads with network allowlists, suspend/resume and ax ssh observability at cluster scale.

k8sorchestrationsandboxdeclarative

harnessGitHub

caelis↗

caelis-labs

Local-first multi-agent coding harness that binds model providers and ACP agents to specialized roles inside a shared session.

Use caseUse it to coordinate specialized coding roles (planner, implementer, reviewer) without leaving your machine.

local-firstmulti-agentrolesacp

repoGitHub

CodeAF↗

Agent-Field

Open-source software factory harness aimed at open models, providing CLI agent fleets and coding workflows.

Use caseUse it to stand up a local software factory that drives open-weight coding agents through standardized pipelines.

open-modelsfactoryclifleet

harnessGitHub

HarnessOfHarness↗

Flesymeb

Framework that wraps existing coding-agent harnesses into multi-day planning-coding-testing loops with continual self-improvement.

Use caseUse it to let an agent autonomously develop a full playable game or complex project across dozens of iteration cycles.

continualmulti-dayautonomousloop

harnessGitHub

openhuman↗

tinyhumansai

Open-source agent harness with local-first memory, orchestration and workflows packaged as a privacy-focused desktop runtime.

Use caseUse it to run personal agents that keep all state on-device while still coordinating multi-step workflows.

local-firstmemoryprivacydesktop

repoGitHub

AHE (Agentic Harness Engineering)↗

china-qijizhifeng

Observability-driven automatic evolution of coding-agent harnesses with evaluate-analyze-improve loops and reported Terminal-Bench lifts.

Use caseUse it to evolve harness components over iterations inside E2B sandboxes and freeze a transferable harness.

evolutionevale2bresearch-origin

toolGitHub

Anthropic Sandbox Runtime (srt)↗

anthropics

OS-level sandbox CLI and library using Seatbelt, bubblewrap, and Windows filters plus proxy-based network allowlists without containers.

Use caseUse it to wrap MCP servers or agent bash with filesystem deny/allow rules and domain-scoped egress via srt.

os-sandboxseatbeltbubblewrapmcp

repoGitHub

Boxed↗

akshayaggarwal99

Self-hosted sovereign code-execution substrate with Go control plane, Rust in-sandbox agent, BYOK auth, and Docker/gVisor-hardened ephemeral sessions.

Use caseUse it to spawn fail-closed Docker sandboxes from Python or TypeScript SDKs and stream artifacts over JSON-RPC.

gorustdockercontrol-plane

harnessGitHub

defending-code-reference-harness↗

anthropics

Reference vuln-finding pipeline that forces every agent into gVisor with egress allowlist proxy and never mounts credentials into agent reach.

Use caseUse it to study or fork a production-shaped sandboxed agent loop for crash-finding with bin/vp-sandboxed entrypoints.

gvisorsecurityreferencepipeline

harnessGitHub

EnvHarness↗

google-research

Programmable layer that wraps frozen training environments with plugins so EnvRigger can reshape tasks toward agent weaknesses without changing verifiers.

Use caseUse it to co-evolve SWE-bench or WebArena-style envs with your policy via reset/step bridges and targeted component banks.

trainingevalrlgoogle

toolGitHub

landstrip↗

landstrip

OS-level sandbox for coding agents using Landlock, Seatbelt, and AppContainer with JSON policies and drop-in CLI for command runs.

Use caseUse it to run cargo test or agent tools under a parametrized filesystem and network policy without a full container.

landlockpolicyclicross-platform

repoGitHub

meclaw↗

mmeyerlein

Ontology-grounded agentic build system in one Rust binary: actor cells with SQLite, sandboxes, vault, voice, and web surfaces for composing agentic OS graphs.

Use caseUse it to grow a message-routed multi-cell agent system where each actor owns its sandbox and secrets stay in a vault cell.

rustactoragentic-ossandbox

harnessGitHub

POCKET Agent↗

ItsNotAILABS

Long-running repository agent with durable goals, recursive agent harnesses, WASM capsules, budgets, leases, receipts, and detach/reattach sessions.

Use caseUse it to set a multi-hour repo goal, run autonomous work with budgets, detach, and reattach with verifiable receipts.

long-runningwasmreceiptscli

toolGitHub

sandbox-runtime-rs↗

Ghostlock-AI

Rust port of Anthropic sandbox-runtime aiming for much faster startup and smaller binaries with Seatbelt profiles and HTTP proxy filtering.

Use caseUse it to drop a single native srt binary in front of agent processes when Node overhead is unacceptable on macOS.

rustseatbeltperformanceport

harnessGitHub

Agent Runner↗

Design-Arena

Model-agnostic open-source harness that runs the same prompt against parallel sandboxed coding agents for preference collection.

Use caseUse it to benchmark real multi-file coding behavior across providers and build preference ground truth.

evalbenchmarksandboxcoding

repoGitHub

hotcell↗

sinameraji

Local open-source sandbox manager that creates, pauses, and runs agent environments on laptop, VM, or bare metal with Docker, Apple VZ, or Firecracker.

Use caseUse it to spin multiple isolated coding-agent workspaces with ephemeral tokens instead of injecting real API keys.

localsandboxmicrovmdevtools

harnessGitHub

LiteLLM Agent Control Plane↗

LiteLLM-Labs

Unified control plane and API that registers, runs, schedules, and observes agents across multiple runtimes from one UI.

Use caseUse it to expose OpenCode, Hermes, Deep Agents, and managed runtimes behind a single gateway for your team.

control-planegatewaymulti-runtimesessions

repoGitHub

RSIAgent↗

AetherLabsAI

Training-free multi-agent framework for recursive self-improvement that explores environments, verifies outcomes, and stores reusable memory.

Use caseUse it to let fixed-weight agents discover and retain environment knowledge through curriculum, actor, and verifier loops.

self-improvementmulti-agentmemoryresearch

toolGitHub

Stanford Agent↗

StanfordAgent

Open-source terminal daemon and orchestration layer that spawns and monitors many coding agents across machines from one interface.

Use caseUse it to drive native Claude Code, Codex, Pi, and other processes with optional remote relay without wrapping their behavior.

orchestrationdaemonmulti-agentcli

toolGitHub

Steel Browser↗

steel-dev

Open-source browser API and sandbox built for AI agents, with sessions, stealth, proxies, CDP, and self-host or cloud options.

Use caseUse it to give any agent reliable web automation without building browser infrastructure or fighting anti-bot measures.

browsersandboxagentscdp

toolGitHub

SuperHQ↗

superhq-ai

Sandboxed multi-agent orchestration platform that runs coding agents inside microVMs with an auth gateway that never exposes keys.

Use caseUse it to launch isolated Claude Code or Codex workspaces on Apple Silicon with host-side credential injection.

microvmsandboxorchestrationmacos

toolGitHub

agentbox (julianthome)↗

julianthome

Minimal Docker Compose sandbox that launches pi or opencode with Ollama, tmux, and git session branching for reviewable runs.

Use caseUse it to spin a polished local terminal agent environment that auto-wires host Ollama models and keeps changes on a review branch.

dockerpiopencodeollama

harnessGitHub

agentos (iii)↗

iii-experimental / iii-hq

Self-evolving agent OS of narrow Rust workers registering functions and triggers on a shared engine with wasm and microVM sandboxes.

Use caseUse it to compose domain workers for reasoning, memory, security, and execution that evolve under governed self-modification.

rustworkersself-evolvingengine

toolGitHub

AgentOS (Opyt)↗

NarendraPatwardhan / OpytAI

WebAssembly VM giving agents a full Unix computer with shell, files, processes, snapshots, host tools, and capability boundaries.

Use caseUse it to replace bag-of-tools agents with a programmable guest computer that can pipeline shell work and call host-bound tools safely.

wasmvmposixsnapshots

repoGitHub

Ephemora Cell↗

MichaelS1011

Capability-based Wasmtime sandbox for MCP tools and untrusted code with fuel, memory, time, and I/O caps plus signed execution records.

Use caseUse it to run agent-generated or MCP tool code under hard resource budgets and produce auditable signed results.

wasmtimemcpcapabilitiesaudit

toolGitHub / crates

Harn↗

Harn project

Language and runtime for defining agent tasks, prompts, tools, and rules with enforced permissions and saved work history.

Use caseUse it to author reusable agent workflows as Harn programs that the runtime executes with sandbox boundaries and session logs.

languageruntimepermissionsworkflows

toolGitHub

tasking-agent↗

FeynmanZhou

Web console workbench for Deep Agents Code with pluggable sandboxes (local, Cube MicroVM, Tencent) and normalized event tracing.

Use caseUse it to drive and audit a headless coding agent through a three-pane UI with session history, artifacts, and sandbox swaps.

consoledeep-agentscubetracing

toolGitHub

wasmagent-js↗

WasmAgent

Embedded compliance layer with WASM kernels, MCP firewall, capability manifests, signed AEP rollouts, and trace-to-training export.

Use caseUse it to wrap tool calls with policy vetting, emit signed evidence records, and feed verified trajectories into DPO or PPO pipelines.

mcpfirewallcompliancewasm

repoGitHub

wasmsh↗

Mayflower

Bash-compatible WASM shell runtime with VFS, Pyodide Python, 88 utilities, and K8s-scalable dispatcher for dense agent sessions.

Use caseUse it to back Deep Agents or custom loops with an in-process or remote bash-plus-Python sandbox that cannot touch the host.

wasmbashpyodidelangchain

harnessGitHub

Agentnetes↗

SuperagenticAI

Self-organizing multi-agent swarm that invents specialist roles and runs them in isolated sandboxes against a git repo.

Use caseUse it to turn a natural-language goal into parallel scout, engineer, and tester agents with emergent roles.

multi-agentsandboxorchestrationnpx

toolGitHub

Apprentice↗

skarnati20

Slim extensible coding harness written in Common Lisp for REPL-native loops, macros, and custom tools.

Use caseUse it to experiment with macro-defined agent loops inside SBCL instead of a heavy TUI product.

common-lispreplminimalexperimental

toolGitHub

Forcefield↗

fabledruns

Lightweight local-first Go agent harness as a single binary with tools, skills, sessions, memory, and permissions.

Use caseUse it to run specialized local coding agents with fast startup and no account or telemetry requirement.

golocal-firstcliharness

harnessGitHub

Letta↗

Letta

Stateful agent runtime in the MemGPT lineage where agents edit their own long-term memory with tools.

Use caseUse it to run agents that manage hierarchical memory as first-class OS-style state rather than prompt stuffing.

memoryruntimestatefulmemgpt

toolGitHub

Mem0↗

Mem0

Drop-in multi-level memory layer that extracts facts and retrieves them for agents and apps across sessions.

Use caseUse it to bolt persistent user, session, and agent memory onto any coding or assistant harness.

memoryfactssdkproduction

repoGitHub

0xferrous agent-box↗

0xferrous

Sandboxed containers for coding agents with disposable Git or Jujutsu workspaces and optional Portal host capability mediation.

Use caseUse it to spin Nix-reproducible agent images that discard worktrees after a run.

nixworkspacegitsandbox

toolGitHub

agent-hop↗

hetpatel-11

Rust runtime that opens real coding harnesses in a PTY, owns chrome around them, and hops a live session between Claude Code, Codex, OpenCode, Pi, and Grok.

Use caseUse it to move an in-progress coding thread to another harness without restarting or losing local session search.

rustptysessionmulti-harness

toolGitHub

AgentLens↗

agentkitai

Tamper-evident hash-chained audit logs for AI agents with OTel-native ingestion and cryptographically verifiable export snapshots.

Use caseUse it to prove every LLM call, tool call, and approval in a chain that fails verification if any record is altered.

auditotelobservabilitycompliance

repoGitHub

agentmemory↗

JordanMcCann

Memory operating system for agents with knowledge graph, consolidation pipeline, and leading LongMemEval retrieval scores.

Use caseUse it to give long-horizon agents durable multi-session recall, updates, and preference tracking under real retrieval.

memorygraphlongmemevalretrieval

toolGitHub

BossConsole↗

risa-labs-inc

Native multi-threaded JVM operator console (not Electron) that hosts coding agents with real browser, terminal, editor, secrets, and 100-plus MCP tools.

Use caseUse it as a desktop control plane to supervise multiple agent sessions with hot-reload plugins and RBAC.

desktopjvmmcpmulti-agent

toolGitHub

Brig↗

brig-sh / NOFire AI

Go CLI and session daemon that boots coding agents inside local microVMs with project mounts, credential delivery, and image verification.

Use caseUse it to run a coding agent on one project directory so a bad command cannot touch the rest of the host.

microvmsandboxcligo

toolGitHub

Cloudflare Agents↗

cloudflare

SDK for persistent stateful agents on Durable Objects with MCP, workflows, voice, browser agents, code mode, and sandboxed execution.

Use caseUse it to deploy always-on edge agents that keep state, schedule work, and call tools without a separate control plane.

durable-objectsedgemcpworkflows

repoGitHub

Harness-RL↗

jiangxinke

Black-box RL stack for training language agents inside multi-agent harnesses with action-args decoupling and conflict-aware policy optimization.

Use caseUse it to train central or joint multi-agent policies without flattening whole trajectories into one token sequence.

rlmulti-agenttrainingcapo

toolGitHub

mattolson agent-sandbox↗

mattolson

Local locked-down sandbox with minimal filesystem access, sidecar egress proxy for hostname policies, and secret injection so the agent never sees raw keys.

Use caseUse it to run coding agents under network allowlists and secret proxies from CLI or devcontainers.

proxysecretsdevcontaineregress

repoGitHub

PicoClaw↗

breakcafe

Serverless-first Claude agent runtime forked for request-driven HTTP with persistent memory, scheduled tasks, and MCP on Lambda-style platforms.

Use caseUse it to host stateful agent conversations and skills as per-request containers without an always-on orchestrator.

serverlesslambdamcpmemory

harnessGitHub

reef-eval↗

Human-Agent-Society

Evaluation infrastructure for self-evolving agents on the Harbor task standard, measuring whether memory, skills, or harness changes improve scores.

Use caseUse it to score autoresearch and containerized tasks before and after an agent persists learned state.

evalself-evolvingharborbenchmark

harnessGitHub

siyad01 agentbox↗

siyad01

Go sandboxed runtime with zero-trust permission manifests, gVisor isolation, credential vault, immutable audit log, and kill switch.

Use caseUse it to declare exactly what an agent may touch and auto-kill on limit breach for untrusted code.

gvisorzero-trustgoaudit

toolGitHub

tsilva agentbox↗

tsilva

CLI that launches Claude Code or Codex with full autonomy inside an isolated Docker container while host credentials and sensitive paths stay outside.

Use caseUse it to run yolo-mode agent sessions on a trusted project without permission prompts or host leakage.

dockersandboxcliisolation

harnessGitHub

Agent Harness Optimizer↗

Airbnb

Benchmark-agnostic framework that evolves system prompts and tool-call middleware via eval feedback using genetic or linear optimizers.

Use caseUse it to automatically lift pass rates on coding or tool-use benchmarks by editing only the harness surfaces.

optimizerpythonevalmiddleware

harnessGitHub

agent-swarm↗

desplega-ai

Open-source agentic OS that lets a lead agent dispatch goals to isolated worker containers running various coding harnesses with shared memory and review gates.

Use caseUse it to run Slack- or GitHub-triggered multi-agent fleets with Docker isolation and schema-validated results.

multi-agentdockerorchestrationos

repoGitHub

AI Coding Agent Harness (minimal)↗

Zelmoghazy

Minimal Python example that turns a project folder into an isolated Podman sandbox for tool-calling coding agents.

Use caseUse it to prototype a secure agent loop with network-disabled containers and resource caps.

pythonpodmanminimalsandbox

harnessGitHub

Atomic↗

bastani-inc

Verifiable coding-agent runtime that encodes processes as stages, checks, gates and approval graphs instead of free-form prompts.

Use caseUse it to define durable engineering loops with explicit checkpoints and subagent delegation for long-horizon tasks.

typescriptworkflowgatesverifiable

toolGitHub

Atomic Agent↗

AtomicBot-ai

Local-first AI agent that runs open-weight models via llama.cpp, drives browser and shell with approvals, and persists memory across sessions.

Use caseUse it to keep private multi-step agent work entirely on-device with local models and MCP tools.

local-firstllama.cpptuimemory

repoGitHub

Atomic Agents↗

Eigenwise

Lightweight modular framework for building agentic pipelines from single-purpose reusable components with clear schemas.

Use caseUse it to compose predictable LEGO-style agents and tools without heavy framework lock-in.

pythonmodularatomicpipeline

harnessGitHub

Beagle↗

Salesforce AI Research

Framework to evaluate and evolve agent harnesses at scale with DarwinX as the core evolution algorithm and verifier-backed tasks.

Use caseUse it to search for harness changes that improve capability while guarding against regressions.

evolutionevalresearchharness

toolGitHub

GoatCode↗

Arhan-w

Single-binary terminal AI agent with 180+ providers, automatic failover mid-session, prompt caching, parallel subagents and rewind.

Use caseUse it to keep coding sessions alive across quota limits with live provider switching and cost tracking.

clifailovermulti-providerbinary

toolGitHub

Herdr Agent Inbox↗

douglascorrea

Plugin that adds session titles, settle triage, workspace rollups and resumable chat history for agents running inside Herdr.

Use caseUse it to treat agent panes like an inbox you can settle and reopen with native session resume.

pluginherdrinboxsession

repoGitHub

Nightona↗

nightona-co

Community fork continuing the last open AGPL Daytona release as self-hostable elastic sandbox infrastructure for AI code execution.

Use caseUse it to keep a fully open sandbox runtime alive after the original project went private.

sandboxforkself-hostagpl

harnessGitHub

Vercel AI Harness↗

Vercel

Experimental HarnessAgent plus harness specification with network session sandbox interface for bridge-backed coding agents.

Use caseUse it to wire Claude Code style harnesses into Vercel sandboxes with streaming and tool execution.

typescriptsandboxsdkexperimental

harnessGitHub

Agent Reliability Harness↗

SUNRNEHUI

Plan-native continuity layer with intent-to-contract synthesis, durable handoff, and evidence-based acceptance.

Use caseUse it to keep multi-session coding work portable across model and runtime boundaries with audit modes.

continuitycontractsacceptance

toolGitHub

agent-browser↗

vercel-labs

Rust agent browser infrastructure aimed at fast, scriptable browser control for agent loops.

Use caseUse it to give coding or research agents a low-latency browser surface without a full desktop stack.

browserrustinfra

harnessGitHub

AgentOS (smartcomputer)↗

smartcomputer-ai

Rust harness for self-evolving agents with deterministic replay, signed receipts, and governed self-modification.

Use caseUse it to let agents propose and apply harness changes under audit trails and simulation gates.

self-modifyingrustgovernance

toolGitHub

aichat↗

sigoden

All-in-one Rust LLM CLI with shell integration, RAG, and agent-style tool use suitable as a thin local harness.

Use caseUse it to script provider-agnostic tool loops from the terminal without a heavy IDE agent.

clirustllm

harnessGitHub

HarnessRouter↗

HarnessRouter

Self-hosted unified API that turns existing coding harnesses into backends via the Unified Harness Protocol.

Use caseUse it to route product tasks across Codex, Hermes, and Pi through one session-aware OpenAI-compatible endpoint.

routeruhpself-hosted

repoGitHub

IronClaw↗

nearai

Privacy and security focused Agent OS in Rust with extensible channels, WASM lanes, and supervised autonomy.

Use caseUse it to self-host a multi-channel personal agent stack with OS-level sandbox defaults.

rustprivacyagent-os

toolGitHub

llmfit↗

AlexsJones

Rust CLI and TUI that scores which local LLMs fit your CPU, RAM, and GPU before you wire them into agents.

Use caseUse it to pick quantizations and runtimes that actually sustain agent loops on your hardware.

local-llmhardwaretui

harnessMicrosoft Learn

Microsoft Agent Framework Harness↗

Microsoft

Batteries-included harness agent for research, coding, and long-running work over any chat client.

Use caseUse it to wrap an IChatClient into sessioned multi-step agents with approval and context controls.

dotnetpythonharness

toolGitHub

oh-my-agentic-coder↗

TNG

Harness-agnostic Go CLI that sandboxes coding agents with Seatbelt, bubblewrap, and Landlock while bridging skills and secrets.

Use caseUse it to confine OpenCode, Pi, or CodeWhale sessions so the harness never holds raw secrets.

sandboxgoos-primitives

toolGitHub

OpenFang↗

RightNow-AI

Single-binary Rust Agent OS with channels, skills, providers, scheduled Hands, and a local dashboard.

Use caseUse it to run always-on autonomous agents from one ~32MB binary without a Python dependency tree.

rustagent-ossingle-binary

harnessGitHub

OpenRig↗

mvschwarz

YAML-defined multi-agent rig that boots mixed coding harnesses as a coordinated team.

Use caseUse it to declare Claude-side and Codex-side agents in one config and launch them together.

multi-agentyamlorchestration

toolGitHub

Prime Agent↗

PrimeIntellect-ai

Self-improving RLM coding and research agent with a continual harness for durable skills, memory, and subagents.

Use caseUse it to run long-horizon research loops where context lives as REPL variables and refinable harness state.

rlmresearchcontinual

harnessGitHub

Rebuno↗

rebuno

Production execution runtime that records every tool and LLM call as durable steps with YAML policy gates.

Use caseUse it to resume interrupted multi-framework agents from Postgres event logs with approval holds.

durablepolicygo

repoGitHub

rig↗

0xPlaygrounds

Rust agent framework for composing model providers, tools, and agent loops with strong typing.

Use caseUse it to build custom systems-language agents that share one provider-agnostic core.

rustframeworkagents

toolGitHub

Agent Work Runtime↗

originoneai

Local Rust CLI and MCP that indexes project Markdown/YAML, records checkpoints, and compiles bounded context packets without model calls.

Use caseUse it to hand a new session only the current goal, unfinished work, and next action instead of the whole history.

contextcheckpointmcprust

harnessGitHub

agent-harness-kit↗

enmanuelmag

Provider-agnostic scaffolding with task backlog, five-role workflow, health gate, MCP server, and persistent action logs.

Use caseUse it to force Lead/Explorer/Builder/Reviewer roles and a green health check before any agent touches the codebase.

mcpscaffoldingmulti-agentaudit

toolGitHub

agentcage↗

agentcage

Defense-in-depth proxy sandbox with default-deny egress, zero-leak secret placeholders, TLS inspection, and multi-backend isolation.

Use caseUse it to run any coding agent behind an inspecting gateway so real keys never enter the cage and only allowlisted domains resolve.

sandboxegresssecretsmitmproxy

toolGitHub

aide↗

jskswamy

One-command OS-native sandbox launcher for any coding agent with Seatbelt/Landlock, capability unlocks, encrypted secrets, and live statusline.

Use caseUse it to stop babysitting allow prompts while still unlocking docker/k8s/gcp only when a project needs them.

sandboxseatbeltlandlockcapabilities

repoGitHub

Awesome Agent Sandbox↗

fishman

Curated map of portable microVM and container isolation harnesses for coding agents with boot-time and mount comparisons.

Use caseUse it to pick and clone the right microVM or rootless container primitive before wiring your own agent loop.

sandboxmicrovmawesome-listisolation

toolGitHub

hcom↗

aannoo

Rust CLI that lets heterogeneous coding agents message, watch, spawn, fork, and subscribe across real terminals without changing how you launch them.

Use caseUse it to wire Claude, Codex, Pi, and others as each other's subagents with collision detection and a TUI dashboard.

cross-agentmessagingrustcli

harnessGitHub

Hive↗

aden-hive

Production multi-agent runtime where a Queen pilots work then fans out worker clones with crash-safe state, cost limits, and human oversight.

Use caseUse it to turn a business outcome into a colony of long-running agents with shared ledger and park/resume.

coloniesproductionHITLmulti-agent

harnessGitHub

IntentKit↗

crestalnetwork

Self-hosted cloud agent cluster that manages collaborative teams of agents around intents rather than one-off chats.

Use caseUse it to stand up a multi-agent cluster that keeps working a shared intent with local ownership of state.

clusterintentmulti-agentself-hosted

toolGitHub

nanobot↗

HKUDS

Ultra-light self-hosted personal agent framework with WebUI, memory, MCP, multi-agent delegation, cron, and OpenAI-compatible API.

Use caseUse it to run a small readable core that coordinates helpers, tools, and chat-app gateways on your own box.

self-hostedmemorymcppersonal-agent

harnessGitHub

Neo↗

owainlewis

Minimalist Go multi-agent coding harness with visible plans, parallel subagents, sandbox-first tools, and a single native binary.

Use caseUse it to drive repo tasks from inspection through tests and review in one terminal without a heavy plugin stack.

gomulti-agentcoding-harnesssandbox

harnessGitHub

Open Multi-Agent↗

open-multi-agent

Self-hosted TypeScript runtime where consequential actions wait for durable approvals and every run leaves a byte-verifiable record.

Use caseUse it to run organizational agents you can own, approve offline, and audit without a hosted control plane.

approvalsaudittypescriptself-hosted

repoGitHub

OpenEvolve↗

algorithmicsuperintelligence

Open-source AlphaEvolve-style evolutionary coding agent that iteratively refines algorithms with ensembles and evaluation loops.

Use caseUse it to clone a research-origin optimizer loop that discovers stronger code under fixed eval harnesses.

evolutionarycoding-agentresearch-originoptimizer

harnessGitHub

Runloop↗

0Albiere

Bun-native production agent runtime with Postgres persistence, BullMQ distribution, type-safe tools, and built-in observability.

Use caseUse it to run resilient multi-worker agent loops that survive crashes with full step history in Postgres.

bunpostgresdistributedruntime

harnessGitHub

runx↗

runxhq

Governed runtime under skills and graphs that admits each act under narrowing authority, injects credentials off-prompt, and seals verifiable receipts.

Use caseUse it to execute portable SKILL.md workflows with policy and audit without embedding another agent framework.

skillsgovernancereceiptsauthority

harnessGitHub

Rusty↗

dev-amjad-shaikh

Durable LangGraph-style agent runtime in Rust with checkpointed super-steps, WASM nodes, remote workers, and a single static server binary.

Use caseUse it to run production graphs with fork/replay, Flight Recorder journals, and Python/TS clients talking HTTP/SSE.

rustdurablecheckpointwasm

harnessGitHub

Trellis↗

mindfold-ai

Repo-native engineering harness that persists specs, task PRDs, journals, and multi-platform agent hooks so sessions stop starting from zero.

Use caseUse it to inject scoped conventions and task context into any coding agent across a monorepo team.

specsmemorymulti-platformagentic-coding

toolGitHub

vibesdk↗

cloudflare

Open-source vibe-coding platform kit built entirely on the Cloudflare stack so you can host your own agent coding surface.

Use caseUse it to clone and run a Cloudflare-native coding agent platform instead of renting a closed IDE agent.

cloudflarevibe-codingplatformedge

harnessGitHub

Vilano Runtime↗

vilano-ai

Durable BEAM-kernel runtime with disposable TS workers, replay-from-top workflows, leases, and supervised long-lived keyed agents.

Use caseUse it to replace retry soup with deterministic replay and passivation for production agent systems.

BEAMdurablereplaytypescript

toolGitHub

agent_harness (Agent Zero plugin)↗

a0-community-plugins

Plugin that adds coding workflows, safety checkpoints, per-chat workspaces, and optional parallel task graphs to Agent Zero.

Use caseUse it to upgrade Agent Zero with pro/ultra modes, action-bound approvals, and task-graph parallel subagents without touching core code.

plugintask-graphcheckpointworkspace

harnessGitHub

agent-execution-harness↗

lordaeternus

Evidence-backed execution harness that forces plans, gates, artifacts, codebase memory, learning loops, and verified claims before an agent can say done.

Use caseUse it to wrap any coding agent so every task produces auditable evidence, finish checks, and compact learning notes without extra token bloat.

evidenceverificationplanmemory

repoGitHub

agent-harness-guide↗

paolo-perrone

Five runnable layers of an agent harness, each demonstrating the failure it prevents, with no API key required.

Use caseUse it to clone and run the demos that show execution boundaries, sandboxing, memory, verification, and context so you can harden your own loop.

educationallayerssandboxdemo

repoGitHub

agentic-coding-harness-benchmarks↗

aarora79

Benchmark harness that drives real long-horizon coding tasks through multiple agents and models then plots cost/quality Pareto frontiers.

Use caseUse it to score models across harnesses on your own repos, produce a live frontier, and let a swe-router skill pick the cheapest model that clears the bar.

benchmarkparetoevalcost

repoGitHub

agentic-harness (sevenschulte)↗

sevenschulte

Reference six-layer harness for agentic coding with identity, rules, skills, hooks, memory, and adapters for multiple runtimes.

Use caseUse it to clone a working reference, adapt the six layers to your preferred agent, and ship a fork-friendly team harness in an afternoon.

referencelayersskillshooks

repoGitHub

agentic-stack↗

codejunkie99

Portable .agent/ folder carrying memory, skills, and protocols that plugs into many coding harnesses so knowledge survives tool switches.

Use caseUse it to drop one brain into a project and keep the same skills and memory when moving between Claude Code, Cursor, OpenCode, Hermes, or a DIY Python loop.

memoryskillsportablemulti-harness

repoGitHub

agents-best-practices↗

DenisSergeevitch

Provider-neutral Agent Skill for designing, generating MVP blueprints, auditing, and refactoring agentic harnesses.

Use caseUse it to generate a production-safe harness blueprint for a domain, then audit an existing loop for missing authorization and observation rules.

skillblueprintauditdesign

harnessGitHub

AgentsMesh↗

AgentsMesh

AI agent workforce platform that schedules, isolates, and steers hundreds of coding agents across self-hosted runner fleets from one console.

Use caseUse it to install runners on your machines, schedule agent pods with capacity limits, and command a large fleet without one-box bottlenecks.

fleetschedulerself-hostworkforce

harnessGitHub

BlitzOS↗

blitzdotdev

Self-hostable control plane and workspace runtime that gives teammates zero-setup agent environments with shared credentials, ACP harness support, and cloud VMs.

Use caseUse it to provision isolated agent workspaces for a team, inject org credentials, and run any ACP-compatible coding agent on Hetzner or AWS.

control-planeworkspaceself-hostacp

harnessGitHub

Gas Town↗

gastownhall

Multi-agent workspace manager with git-backed persistent hooks, mailboxes, and a Mayor coordinator for reliable long-running coding agent fleets.

Use caseUse it to keep work state across agent restarts, hand off tasks via persistent hooks, and scale to dozens of agents without losing context.

persistencemulti-agentworkspacecoordinator

toolGitHub

Maestro↗

RunMaestro

Cross-platform desktop command center for orchestrating fleets of coding agents with git worktrees, auto-run playbooks, and parallel isolated sessions.

Use caseUse it to run unlimited agents in parallel across projects, auto-execute markdown playbooks for long unattended runs, and merge worktree results with one click.

orchestrationdesktopworktreefleet

harnessGitHub

ruflo↗

ruvnet

Meta-harness that turns Claude Code or Codex into coordinated swarms with adaptive memory, federation, 100+ specialized agents, and self-learning loops.

Use caseUse it to init a nervous system around your existing coding agent so tasks auto-route, learn from success, and federate securely across machines.

swarmmemoryfederationmeta-harness

repoGitHub

strands-agents tools↗

strands-agents

Companion tool pack for the Strands harness SDK giving agents file, shell, browser, and domain capabilities under lifecycle controls.

Use caseUse it to wire production-ready tools into a Strands agent loop with turn limits, budgets, MCP, and tracing already in place.

toolssdkmcpproduction

repoGitHub

superpowers↗

obra

Composable skills framework and software development methodology that forces specs, TDD plans, and subagent-driven execution across many coding agents.

Use caseUse it to install skills that make any supported harness pause for design sign-off then drive red-green TDD subagents until the plan is complete.

skillstddmethodologymulti-agent

harnessGitHub

Symphony↗

openai

Spec and reference that turns tracker issues into isolated autonomous implementation runs with proof-of-work artifacts for landing PRs.

Use caseUse it to watch Linear or GitHub issues, spawn sandboxed coding agents per ticket, and accept only runs that ship CI status plus walkthrough proof.

autonomousissueprooforchestration

harnessGitHub

Agent Governance Toolkit↗

microsoft

Runtime policy engine and mesh packages that enforce OWASP agentic risks at sub-millisecond latency across languages.

Use caseUse it to intercept every tool call with YAML, OPA, or Cedar rules before side effects leave the agent process.

governancepolicyruntimesecurity

harnessGitHub

Agent Machines↗

Kevin-Liu-01

Control plane that keeps Worker identity, memory, and evidence while routing runtimes and sandbox substrates underneath.

Use caseUse it to provision specialist workers once and swap E2B, Daytona, or Vercel sandboxes without rewriting the agent contract.

control-planeworkersroutingfleet

harnessGitHub

Agent Orchestrator↗

Untrivial-ai

Supervise teams of coding agents from plan to merge across 27 harnesses with desktop, web, mobile, and cloud surfaces.

Use caseUse it to split a project into workspaces, assign any supported harness, and track PRs and reviews in one Kanban.

orchestrationmulti-agentfleetkanban

repoDocs

Agent Patterns RAH↗

AgentPatterns.ai

Pattern where a parent agent spawns full subagent harnesses in parallel rather than bare model calls.

Use caseUse it to structure long jobs so the recursive unit carries filesystem tools, planning, and its own context.

patternrecursivesubagents

harnessGitHub

agent-harness (lib.rs style)↗

Tosin Amuda

Rust crate that drives multiple coding agents behind one trait with normalized streaming RunEvent vocabulary.

Use caseUse it to call Claude Code, Codex, or OpenAI-compatible loops from Rust without parsing each CLI format.

rustunified-apistreamingmulti-provider

harnessGitHub

agent-harness (Siddhant)↗

Siddhant-K-code

Local BYOK coding harness with project chat, isolated Docker or AgentCore runs, and independent patch verification.

Use caseUse it to turn a repo question into a budgeted coding run whose patch only lands after an external verifier passes.

verifierbyokisolatedcoding

harnessGitHub

agent-harness-rs↗

yifanes

Rust agent loop with local tools, MCP, compaction, silent-stop detection, and optional E2B sandbox runtime.

Use caseUse it to embed a typed streaming agent loop in a systems binary with pluggable sandbox executors.

rustagent-loopmcpsandbox

repoGitHub

All-The-Vibes Agent-Harness↗

All-The-Vibes

Five-pillar framework, white paper, and prompt guide for building harnesses around context, tools, loops, and policy.

Use caseUse it to scaffold and test your own orchestration layer with explicit continue, retry, and halt signals.

frameworkpillarspromptsdesign

harnessGitHub

Bounded Agent Harness↗

cexplayer01

Deterministic control plane that compiles validated plans into specialist workflows with authority, budget, and contract checks.

Use caseUse it to fail closed on capability mismatch, budget overflow, or unknown contracts before any model call runs.

deterministiccontractsspecialistscontrol-plane

harnessGitHub

CAGE↗

google

Domain-agnostic Kubernetes governance substrate with control barrier functions, consensus, and cryptographic evidence.

Use caseUse it to wrap autonomous agents in non-bypassable pipelines that escalate to humans with sealed audit trails.

governancekubernetessafetyaudit

toolBlog

Docker Sandboxes in GHA↗

Docker

MicroVM sandboxes as a GitHub Agentic Workflows runtime so agents can run containers under network policy.

Use caseUse it to let CI agents fix integration tests with Testcontainers while the runner stays isolated.

sandboxcigithub-actionsmicrovm

toolGitHub

harnext↗

QualityUnit

Terminal coding agent plus CI harness that generates staged GitHub Actions from issue labels to merged PR.

Use caseUse it to wire an interactive REPL and self-hosted runner that carries labeled issues through verify and merge.

clicigithub-actionscoding

toolGitHub

Headroom↗

headroomlabs-ai

Content-aware compressor for tool outputs, logs, files, and RAG that drops in as library, proxy, or MCP server.

Use caseUse it to cut coding-agent token spend 20 percent or more while keeping full originals retrievable on demand.

compressioncontextproxymcp

harnessGitHub/Blog

Omnigent↗

Databricks

Apache-2.0 meta-harness that wraps existing agents in sandboxed sessions with composition, cost policies, and OS sandbox.

Use caseUse it to compose multiple harnesses under shared policy and pause runs after a dollar budget threshold.

meta-harnesscompositionpolicysandbox

repoGitHub

Open Executive↗

SenteLabsAI

Virtual executive persona backed by eight specialist agents behind a single coherent FastAPI and Next.js surface.

Use caseUse it to clone a multi-specialist executive stack and route strategy, finance, and ops questions through one voice.

multi-agentexecutivespecialists

toolGitHub

Plandex↗

plandex-ai

Terminal coding agent for large multi-file tasks with cumulative diff sandbox, project maps, and configurable autonomy.

Use caseUse it to plan and apply changes spanning dozens of files while keeping diffs isolated until you accept them.

clilarge-contextdiff-sandboxcoding

repoGitHub

Sandbox0↗

sandbox0-ai

Persistent encrypted gVisor sandboxes scheduled by Nomad, with durable RootFS in object storage and replaceable compute nodes.

Use caseUse it to run long-lived agent workspaces that pause and resume identity without treating every session as disposable.

sandboxgvisornomadpersistent

repoDocs

Session Harness Sandbox Separation↗

AgentPatterns.ai

Split long-running agents into append-only session log, stateless harness, and provisioned sandbox primitives.

Use caseUse it to crash-recover by waking any harness instance against the durable session and a fresh sandbox.

patternsessionsandboxrecovery

repoGitHub

Strands-adjacent tools pack note↗

community

Daily-updated star ranking of coding agents that surfaces mid-tier movers outside household CLIs.

Use caseUse it to scan 7-day delta movers and clone rising harnesses before they hit mainstream lists.

catalogrankingsdiscovery

repoa11.to

A11↗

helenapankov

Apache 2.0 layered toolkit of typed streams and reusable actions for building agentic and multimodal apps.

Use caseUse it to compose local helpers, model tools, RPCs, and worker jobs from the same action definitions without framework lock-in.

streamsactionslayeredmultimodal

toolGitHub

agent-run↗

sin-ack

Tiny standalone binary that runs a coding agent inside a bwrap sandbox with simple TOML config.

Use caseUse it to launch pi, opencode, codex, or claude under namespace isolation on Linux with one binary.

sandboxbwrapclilightweight

repoGitHub

Agentic Coding Tools↗

jankneumann

Harness-agnostic skills and primitives for orchestrators, workers, and validators with scope-isolated parallelism.

Use caseUse it to install Markdown skills that coordinate multi-agent worktrees, handoffs, and adversarial validation.

skillsorchestrationworktreeslong-horizon

toolGitHub

Apache Maka↗

apache

High-performance agent workspace that keeps a complete event-sourced record of every action.

Use caseUse it to run local-first agents with full audit trails and tool-use history for reproducible sessions.

event-sourcingworkspacelocal-firstapache

repoGitHub

Astrid↗

astrid-runtime

Portable capability-secure OS runtime built from WebAssembly capsules that compose without inheriting full authority.

Use caseUse it to run agent workloads as isolated capsules with explicit capabilities on macOS or Linux without full VMs.

wasmcapability-securityruntimesandbox

toolGitHub

Benzi↗

oooscoos

Code intelligence harness delivered as a VS Code extension with upcoming MCP and headless support.

Use caseUse it to replace ad-hoc graph tools with a structured intelligence layer that agents query inside the editor.

vscodecode-intelligenceharnessmcp

toolGitHub

Booley↗

boldaxolotl

Open-source IDE sandbox that wires agent CLIs to EDA tools for SystemVerilog chip design via MCP.

Use caseUse it to let agents run simulation, synthesis, and waveform inspection under deterministic quality gates.

edahardwaremcpsandbox

toolGitHub

clawk↗

clawkwork

CLI that boots a disposable Linux microVM per project so coding agents run with root inside the guest while host files and keys stay unreachable.

Use caseUse it to attach Claude Code, Codex, or a shell to a per-repo VM with network allow-lists and resume via attach without Docker.

sandboxmicrovmcliisolation

harnessGitHub

Codely Agent Harness↗

CodelyTV

Shared skills, plugins, hooks, and utilities that install across agents to enforce conventions and improve output quality.

Use caseUse it to add reusable /skills for docs, quality gates, and SDLC workflows that any compatible agent can discover.

skillshooksconventionsmulti-agent

toolGitHub

Feature Ledger↗

netizer

CLI that automatically tracks implemented features from agent work and produces client and team reports.

Use caseUse it to bootstrap, audit, and release-cut feature inventories so agents keep documentation current without manual effort.

docstrackingcliagent-workflow

harnessGitHub

HALO agent-harness↗

doubts-suplab

Language-neutral governance runtime with confidence gates, default-deny tools, audit, human review, and kill switch.

Use caseUse it to wrap any agent decision path so side-effecting actions stay governed regardless of model or host language.

governanceauditcontrol-planeenterprise

harnessGitHub

Latentic agent-harness↗

getlatentic

Rust crate that drives existing agent CLIs programmatically through one Harness trait and a normalized event stream.

Use caseUse it to embed Claude Code, Codex, or OpenAI-compatible agents in your own process without scraping terminals.

rustcli-streamprogrammaticevent-stream

toolGitHub

MaskShift↗

nafeeur

Maximalist local-first coding harness with 149 native tools, zero npm runtime deps, lazy MCP, and bridges to other agents.

Use caseUse it to give any model a full control plane for LSP, containers, SSH, Git worktrees, and skills while keeping only relevant tools in context.

harnessclizero-depsmulti-provider

harnessGitLab

Opair↗

philbooth

Coding harness that deliberately limits autonomy with scoped tools, access control, and driver/navigator pair modes.

Use caseUse it to keep the human in the loop as a true pair programmer instead of reviewing giant terminal diffs.

pair-programmingrestrictedhuman-in-loopmcp

harnessGitHub

Open-PTC↗

daly2211

Proxy and Deno-isolate runtime for programmatic tool calling over MCP so models write TypeScript to orchestrate tools.

Use caseUse it to cut tool-definition bloat and multi-round latency by executing loops and filters inside a secure isolate.

ptcdenomcpproxy

harnessGitHub

open-ptc-agent↗

Chen-zexi

Open implementation of programmatic tool calling that lets the model write code to invoke MCP tools inside a Daytona sandbox instead of serial JSON calls.

Use caseUse it to collapse multi-step tool loops into one code-execution turn with progressive discovery and session persistence.

ptcmcpsandboxlanggraph

harnessGitHub

OpenMetaHarness↗

openmetaharness

One-file bootloader and README pattern that gives coding agents persistent memory, judgment, and operating discipline across sessions.

Use caseUse it to drop a model-agnostic operating file into any project so long-horizon work compounds and resumes cleanly.

metabootloaderlong-horizonpersistent

toolGitHub

Ridge↗

vasinov

Resource mesh that gives agents a uniform interface to local projects, Docker, SSH, and S3 with capability contracts.

Use caseUse it to let agents discover, copy, and execute across machines without stuffing file contents into context.

mcpresourcesmulti-machinedelegation

harnessGitHub

Toolcraft↗

pixel-point

MIT starter kit, UI library, and AI harness for building custom design apps that agents can extend.

Use caseUse it to bootstrap a canvas-based design tool with agent skills, checks, and export workflows ready to customize.

designstarterskillsreact

toolGitHub

Treadstone↗

earayu

Agent-native Kubernetes sandbox platform with all-in-one runtime for shell, files, browser, MCP, and long-running state.

Use caseUse it to run agents inside durable sandboxes or expose sandboxes as on-demand tools via CLI, REST, or Python SDK.

kubernetessandboxmcpself-hosted

toolHN / product

Adios.dev sandboxes↗

clovis818

Fast isolated execution sandboxes aimed at AI agents with low cold-start latency for code and tool loops.

Use caseUse it to give agents disposable runtimes that spin up quickly for eval batches or one-shot code execution without long-lived VMs.

sandboxfastexecutionagents

harnessGitHub

Agent Control↗

agentcontrol

Centralized runtime control plane that wraps model and tool calls with configurable evaluators to block injections, PII and policy violations.

Use caseUse it to enforce org-wide guardrails on LangChain, CrewAI or Strands agents via a single @control decorator without redeploying every agent.

guardrailspolicyruntimecontrol-plane

harnessGitHub

Agent Harness Core↗

phenomenoner

Self-hosted Rust runtime for durable long-horizon agent tasks with virtual sessions, sandboxed reasoning jobs, and auditable receipts.

Use caseUse it to leave an agent running on hard multi-day work where continuity, compaction, and recovery are first-class and every step is receipted.

rustdurablelong-horizonreceipts

harnessGitHub

Agent Substrate↗

agent-substrate

High-density control plane for agent sandboxes that multiplexes many idle agents onto fewer workers with sub-second suspend/resume over Kubernetes.

Use caseUse it to schedule large fleets of agent actors onto shared workers so cold starts stay low while density stays high for RL or evals.

control-planekubernetesmultiplexlifecycle

toolGitHub

AgentBox↗

madarco

CLI that launches parallel coding agents inside dedicated sandboxed VMs (local Docker or cloud) with checkpoints, screen sharing, and credential isolation.

Use caseUse it to spin multiple Claude or Codex sessions in isolated boxes so one runaway agent cannot touch your host git credentials or filesystem.

vmparallelclisandbox

toolGitHub

AgentCLI↗

happyvibing

One CLI that turns any MCP server or OpenAPI spec into dynamic commands so agents discover tools on demand instead of loading every schema.

Use caseUse it to keep agent context lean by registering MCP and REST backends once then calling only the tools needed per turn from the shell.

climcpopenapitools

harnessGitHub

agentcontrolplane (ACP)↗

humanlayer

Kubernetes-native Agent Control Plane for outer-loop agents with durable checkpoints, async tool calls, human feedback and full MCP support.

Use caseUse it to run unsupervised long-running agents that pause on tool calls, checkpoint conversations, and resume after human approval gates.

kubernetesdurablemcpouter-loop

repoGitHub

boxlite / microsandbox family↗

various

Living index of portable self-contained sandboxes including microVMs, containers and isolation harnesses for coding agents.

Use caseUse it to survey local-first options like BoxLite and microsandbox then clone the one that matches your OS and density needs.

awesome-listmicrovmisolationlocal

harnessGitHub

boxxkite↗

EvAlssment

Self-hostable agent sandbox with full bash/python/file tool surface, control plane, four SDKs and MCP server on real Kubernetes pod isolation.

Use caseUse it to point any agent framework at a batteries-included sandbox you run yourself with non-root pods and deny-by-default egress.

kubernetesself-hostmcptools

repoGitHub

Cleanroom / smol-machines patterns↗

fhiltscher et al.

Security-first ranked list of agent sandboxes emphasizing deny-default egress, secrets brokering and isolation strength.

Use caseUse it to pick a sandbox whose egress and secrets model match your threat model before you wire the agent loop.

sandboxsecurityegressawesome-list

repoGitHub

E2B↗

e2b-dev

Open-source secure cloud sandboxes with real tools for enterprise agents, Firecracker isolation, and self-hostable infrastructure.

Use caseUse it to run agent-generated code in disposable microVMs with Python and JS SDKs while keeping the rest of your stack on your laptop.

sandboxfirecrackercode-executionself-host

toolGitHub

gpt-researcher↗

assafelovic

Autonomous deep-research agent harness that produces citation-grounded reports from web and local sources with multi-agent modes.

Use caseUse it to spin a research loop that gathers sources, debates findings, and writes a verifiable report without hand-holding every query.

researchmulti-agentcitationsharness

toolGitHub

Mastra↗

mastra-ai

Modern TypeScript framework for building production AI agents and workflows with model routing, memory, MCP, evals, and sandbox-backed workspaces.

Use caseUse it to scaffold a full agent app with suspend-resume workflows and Observational Memory that you can drop into Next.js or run standalone.

typescriptworkflowsmcpagents

repoGitHub

microsandbox↗

superradcompany

Local-first microVM runtime and multi-language SDKs that give agents hardware-isolated environments with OCI images, secrets brokering, and MCP support.

Use caseUse it to embed sub-second microVMs in your agent loop so untrusted code runs with its own kernel without Docker daemon overhead.

microvmlocal-firstsdkisolation

harnessGitHub

omnara↗

omnara-ai

Open-source managed-agent platform that handles durable execution and state while you choose models, tools, machines and interaction surfaces.

Use caseUse it to launch profile-defined coding agents on Blaxel, Daytona or your own VMs with crash recovery and multi-machine attachment.

manageddurableprofilesmulti-machine

harnessGitHub

OneCLI↗

onecli

Open-source sandboxed agent harness for teams that gives every employee an isolated personal agent with gateway-injected credentials and policy enforcement.

Use caseUse it to provision per-employee agents behind a single org policy so secrets never enter agent context while still allowing Slack and dashboard control.

sandboxteamsgatewaypolicy

repoGitHub

Prismor↗

community

Curated control-plane resources plus runtime hooks that intercept dangerous commands and secret leaks before coding agents execute them.

Use caseUse it to discover and wire policy hooks that sit outside Claude Code or Codex so risky shell calls are blocked at the gateway.

control-planepolicyawesome-listhooks

toolGitHub

sandbox-sdk↗

opencoredev

Typed TypeScript SDK that unifies local, E2B, Daytona, Vercel Sandbox, Railway and other providers behind one createSandbox API.

Use caseUse it to write agent code once and switch sandbox backends from local AgentOS VMs to hosted providers without rewriting execution calls.

sdkmulti-providertypescriptsandbox

repoGitHub

SmolVM↗

CelestoAI

Secure persistent microVM computers for long-running agents with sub-second boot, browser, code execution, and state that survives sessions.

Use caseUse it to give each agent a durable computer that boots fast, persists files, and can be snapshotted for fleets of Grokbot-style workers.

microvmpersistentcomputer-useagents

repoGitHub

smolvm-sdk↗

smol-machines

Official multi-language SDKs for smolVM lightweight microVM sandboxes focused on secure agent code execution.

Use caseUse it to create, exec, and tear down microVMs from Node or Python in under a second for tight agent feedback loops.

sdkmicrovmpythontypescript

repoGitHub

2026-agent-harness↗

bishopZ

Lifecycle system combining persistent wiki-style memory with staged skill discipline and human gates across an eleven-stage idea pipeline.

Use caseUse it to clone a complete on-disk agent workflow that moves ideas from backlog through build and growth with explicit sign-off.

lifecycleskillsmemory

repoGitHub

agent-harness (Go)↗

BA-CalderonMorales

Clean-room Go implementation of production coding-agent harness patterns with TUI, OpenRouter/Anthropic support, and local-first defaults.

Use caseUse it to study or extend a minimal systems-language harness that boots a terminal UI and talks to local or remote models.

GoTUIclean-room

repoGitHub

Claw Code Agent↗

HarnessLab

Zero-external-dependency Python reimplementation of a full coding-agent architecture with plugins, nested delegation, MCP, worktrees, and a local GUI.

Use caseUse it to run a complete local-model coding loop with session persistence and custom agent profiles without Rust or TypeScript toolchains.

Pythonlocal-modelsplugins

repoGitHub

evolving-agent-harnesses↗

prakashkagitha

Research program and code where a fixed small model mines its own failures and redesigns its harness under a verified non-regression gate.

Use caseUse it to evolve a minimal draft-write_test-fix harness with Haiku-class models and measure SWE-bench lifts without weight updates.

self-harnesssmall-modelsSWE-bench

harnessGitHub

GSD Core↗

open-gsd

Meta-prompting and context-engineering system that drives agents through discuss-plan-execute-verify-ship phases in fresh subagent windows to avoid context rot.

Use caseUse it to install phase commands into your preferred coding agent and ship milestones with structured state that survives compaction.

meta-promptingcontextspec-driven

toolGitHub

GUI Agent Harness↗

Fzkuji

CLI that turns an LLM into a desktop GUI agent with iterative visual grounding, memory, and observe-verify-plan-dispatch loop.

Use caseUse it to automate desktop tasks from natural language with screenshot-based element grounding and verification.

GUIgroundingdesktop

harnessGitHub

harnessed↗

easyinplay

Composition orchestrator that assembles upstream skills and agents via manifests into a gated BDD-SDD-TDD workflow without vendoring code.

Use caseUse it to wire gstack, GSD, and superpowers-style packs into one discuss-plan-build-verify-ship engine with checkpoints.

compositionskillsorchestration

harnessGitHub

HarnessX↗

Darwin-Agent

Harness foundry that composes typed processors across nine dimensions, adapts configs from traces, and evolves harnesses plus models from reward-annotated trajectories.

Use caseUse it to forge reusable coding or research harnesses, then let the meta-loop search better processor stacks without rewriting the agent.

foundrycompositionevolution

repoGitHub

Live-SWE-agent↗

OpenAutoCoder

Runtime self-evolving software engineering agent that starts from a minimal bash scaffold and rewrites its own tools and scaffold while solving real issues.

Use caseUse it to run an agent that expands its own capabilities on the fly against SWE-bench style GitHub issues.

self-evolvingSWEminimal

harnessGitHub

Open SWE↗

langchain-ai

Open-source asynchronous coding agent built on Deep Agents that plans, codes, reviews, and opens PRs from GitHub issues or a dashboard.

Use caseUse it to deploy an internal software-factory agent that researches repos, validates changes, and delivers pull requests in isolated environments.

asyncPRLangGraph

toolGitHub

openharness↗

AgentBoardTT

CLI plus SDK coding agent claimed to hit perfect scores on an internal Harness-Bench across multiple providers.

Use caseUse it to run a provider-agnostic coding loop that ships as both interactive CLI and embeddable SDK.

CLISDKmulti-provider

repoGitHub

OpenSandbox↗

opensandbox-group

General-purpose sandbox platform with multi-language SDKs, CLI, MCP, Docker/Kubernetes runtimes, and built-in command, filesystem, and code-interpreter environments.

Use caseUse it to spin up isolated coding-agent or GUI-agent environments with a unified API for local or cluster deployment.

sandboxK8sSDK

toolGitHub

sandbox-agent↗

rivet-dev

Lightweight server that runs inside any sandbox and exposes HTTP/SSE control for coding agents so you can drive them remotely with streaming and permissions.

Use caseUse it to install a static binary into E2B or Docker sandboxes and control Claude-style or OpenCode agents over the network from your app.

sandboxHTTPremote

repoGitHub

ADK-Rust↗

zavora-ai

Production Rust agent development kit with modular crates for models, tools, memory, eval, guardrails, sandbox, and realtime.

Use caseUse it to build type-safe low-overhead agents and serve them over HTTP or voice.

rustsdkmodulareval

harnessGitHub

AgEnD Terminal↗

suzuke

Rust PTY fleet manager that declares multi-agent teams in YAML, launches backends, manages worktrees, and wires MCP between them.

Use caseUse it to run a declared fleet of coding agents with auto-respawn and branch isolation.

fleetptyrustworktrees

repoGitHub

Agent Sandbox (scitix)↗

scitix

Fast multi-cloud sandbox engine with pre-warmed pools, Kubernetes CRDs, and E2B-compatible API for agent and RL workloads.

Use caseUse it to allocate sub-60ms isolated environments for high-frequency agent loops.

sandboxk8srlmulti-cloud

repoGitHub

agent-sandbox (WASM)↗

Parassharmaa

Embeddable WASM sandbox with 80+ CLI tools, shell interpreter, JS runtime, and SSRF-safe networking under 13ms startup.

Use caseUse it to execute agent-generated code without Docker on any host that runs WASM.

wasmsandboxcliembeddable

harnessGitHub

Autonomous Harness↗

autonomous-ai

Hardware-plus-software control plane that routes spoken or typed intent to agents across local and remote machines.

Use caseUse it to drive multiple coding agents from one device as a left-hand control surface.

control-planemulti-machinehardwarecli

harnessGitHub

Bello↗

Makson179

Supervised pipeline that keeps long-horizon coding runs on track with independent review, guards, and cost-aware model assignment.

Use caseUse it to reduce drift and token spend on multi-step coding tasks under a fixed budget.

supervisionreviewcostpipeline

toolGitHub

Bestie↗

jolexxa

Native terminal coding-agent harness focused on full visibility via an inspector pane for every tool call and shell process.

Use caseUse it when you want sandboxing and compaction with zero hidden agent actions.

terminalinspectorsandboxvisibility

toolGitHub

bmo-agent↗

joelhans

Self-improving terminal coding agent that writes new tools when it hits limits and maintains reflection-driven skills.

Use caseUse it to grow a personal toolset automatically across repeated coding sessions.

self-improvingtoolsterminalmemory

toolGitHub

Grok Build↗

xai-org

Rust full-screen TUI coding agent with headless CI mode, ACP embedding, MCP, sandboxing, and plugin hooks.

Use caseUse it to run interactive or scripted coding sessions with ACP editor integration.

rusttuiacpcli

toolGitHub

h5i↗

h5i-dev

Pure-Rust security-first headless browser and multi-tier sandbox (process to microVM) built for agent automation and red-teaming.

Use caseUse it to contain agent web and workspace actions with auditable network policies.

browsersandboxrustsecurity

harnessGitHub

Happy Agent↗

slopus

Universal local harness that reuses your existing provider subscriptions with model-native prompts, tools, durable sessions, and subagents.

Use caseUse it to run one consistent loop across multiple model subscriptions without new accounts.

multi-providersubscriptionstuisessions

repoGitHub

Harness 101↗

adamaoc

Minimal TypeScript coding harness plus line-by-line tutorial explaining every piece of a working agent loop.

Use caseUse it to learn and fork a readable baseline harness before adding production features.

tutorialminimaltypescriptlearning

toolGitHub

HarnessKit↗

RealZST

Desktop and CLI manager that unifies skills, MCP servers, plugins, hooks, configs, memory, and rules across many coding agents.

Use caseUse it to inventory and sync extensions for every agent on your machine from one console.

skillsmcpmulti-agentdesktop

toolGitHub

Mirage↗

strukto-ai

Virtual terminal and filesystem for agents that mounts S3, Drive, Slack and more under one root with virtualized CLIs and runtimes.

Use caseUse it to give agents unix-tool access across heterogeneous data sources without N SDKs.

virtual-terminalvfsclisecurity

harnessGitHub

Opendray↗

Opendray

Self-hosted gateway that keeps coding-agent sessions alive on your server and drives them from web, mobile, or chat channels with shared memory.

Use caseUse it to reattach to long-running agent sessions from any device without SSH fragility.

gatewayself-hostedmulti-channelmemory

harnessGitHub

PluggableHarness Agent↗

pluggableharness

Go microkernel coding harness with seven out-of-process plugin categories, HCL config, policy gate, and durable session replay.

Use caseUse it to assemble a custom agent loop from versioned providers without forking a monolith.

microkernelpluginsgoterminal

harnessGitHub

SandBase Harness↗

sandbaseai

Local-first self-hosted runtime and MCP bridge with sandboxed sessions, credential vault, audit/replay, and a built-in Console.

Use caseUse it to run durable agent sessions on your own infra with full audit trails.

local-firstmcpsandboxconsole

toolGitHub

tlbx↗

tlbx-ai

Self-hosted terminal and agent-controller multiplexer that renders persistent shells and coding-agent UIs in any browser.

Use caseUse it to continue agent work from phone or tablet while the host stays awake.

multiplexerbrowserremoteagents

harnessGitHub

UniHarness↗

UnicomAI

Python agent harness that separates the runtime (keys, config) from a pluggable Computer layer (local, VM, E2B) so the agent cannot read its own secrets.

Use caseUse it to ship CLI, chat, cowork, or headless products from one isolated runtime.

computer-protocolsandboxpythonmcp

harnessGitHub

useAgent↗

useagenthq

Open-source coworker platform that gives existing coding agents their own cloud computer and returns finished artifacts.

Use caseUse it to turn subscription agents into durable team coworkers that hand back PRs and sites.

coworkercloud-computermulti-agentself-hosted

repoGitHub

AgencyBench↗

GAIR-NLP

Open agent benchmark suite focused on realistic multi-step agency tasks beyond simple coding patches.

Use caseUse it to stress-test long-horizon planning and tool use outside SWE-bench style unit tests.

benchmarkagentseval

repoGitHub

Agent-Sandbox↗

agent-sandbox

Self-hosted E2B-compatible sandbox platform for untrusted LLM code, browser use, computer use and multi-tenant isolation on Kubernetes.

Use caseUse it to give every agent turn its own isolated container with shell, VNC and MCP lifecycle control.

sandboxkubernetese2bcomputer-use

toolGitHub

agentic-harness (Rust)↗

codejunkie99

Rust-native agent runtime, SDK and CLI that ships one binary for laptop, CI, remote Linux sandboxes or edge with HTTP session environments.

Use caseUse it to build a coding agent that edits, tests and PRs from a single native binary without a JS runtime.

rustclisandboxcoding

toolGitHub

AgentScope Java↗

agentscope-ai

Production Java framework for distributed long-running agents with workspace sandboxes, multi-agent spawn, session recovery and control-plane dashboard.

Use caseUse it to deploy enterprise multi-agent systems with Redis-backed memory and Kubernetes sandboxes.

javadistributedsandboxmulti-agent

repoGitHub

ai_harness_engineering↗

Cobus Greyling

Minimal reference implementation of six harness components (tools, memory, context, planning, verification, guardrails) with CLI and Gradio demo.

Use caseUse it to study and fork a complete small harness stack powered by Nemotron before building your own.

pythonreferenceguardrailsdemo

harnessGitHub

AutoHarness↗

aiming-lab

Lightweight governance wrapper that turns any LLM client into a governed agent via a 6-to-14 step pipeline, YAML constitutions, risk patterns and audit logs.

Use caseUse it to wrap an existing OpenAI-compatible client in two lines and enforce tool permissions plus cost tracking.

governancepythonsafetymulti-agent

repoGitHub

best-of-Agent-Harnesses↗

RyanAlberts

Weekly-rescored curated list of 100+ harnesses with MCP server, llms.txt and JSON so agents can recommend harnesses by capability.

Use caseUse it as a live catalog and MCP endpoint to let your own agent pick the right harness for a task.

catalogmcpharnessmeta

harnessGitHub

DeepSeek Harness↗

DeepSeek AI

Everything-is-a-plugin agent harness on Cordis where model, tools, loop, sandbox, storage and UI are all swappable plugins under MIT.

Use caseUse it to compose a custom agent loop by mounting only the plugins you need then run the local web UI.

plugintypescriptsandboxopen-source

harnessGitHub

DeerFlow↗

ByteDance

Long-horizon SuperAgent harness on LangGraph with sub-agents, sandboxes, memory, skills and message gateway for multi-hour research and coding tasks.

Use caseUse it to orchestrate lead-plus-subagent research and code workflows that survive minutes to hours.

langgraphsandboxmulti-agentskills

toolGitHub

Google ADK Python↗

Google

Code-first Agent Development Kit with graph workflow runtime, task delegation, HITL tool confirmation, multi-agent hierarchies, and deploy paths to Cloud Run or Vertex.

Use caseUse it to define deterministic agent graphs and eval sets in pure Python then ship them to any model backend.

pythonworkflowmulti-agenteval

harnessGitHub

Harbor↗

harbor-framework

Evaluation and optimization framework that runs arbitrary coding agents against Terminal-Bench and other datasets across thousands of sandboxed environments.

Use caseUse it to benchmark Claude-style or custom agents head-to-head on Terminal-Bench 2.0 with concurrent rollouts.

evalterminal-benchrlpython

harnessGitHub

inspect_ai↗

UKGovernmentBEIS

Flexible framework for LLM evaluations with agents, scorers, datasets and sandboxed tool use aimed at rigorous agent benchmarking.

Use caseUse it to define custom agent eval suites with reproducible scorers and parallel task runners.

evalpythonbenchmarkagents

repoGitHub

lox/agent-harness↗

lox

Minimal composable Go library that implements the core tool-calling agent loop with hooks and thread state.

Use caseUse it to embed a tiny provider-agnostic agent loop inside Go services without pulling a full framework.

gominimaltool-callinglibrary

harnessGitHub

OpenAgentHarness↗

fairyshine

Headless workspace-first agent engine exposing HTTP APIs for sessions, runs, actions, sandboxes and SSE streaming for embedded products.

Use caseUse it as the backend runtime under your own chat UI and tenant model for internal agent platforms.

headlessapisandboxtypescript

harnessGitHub

OpenHarness (HKUDS)↗

HKUDS

Lightweight open agent infrastructure with tool loop, 43+ tools, skills, memory, multi-agent coordination, permissions and a personal ohmo gateway.

Use caseUse it to run a self-hosted personal coding agent over chat channels that forks branches and opens PRs.

pythonskillsmemorymulti-agent

repoGitHub

RepoMaster↗

QuantaAlpha

Repo-scoped research harness that builds function and module graphs so agents explore only needed context with lower token use on coding benches.

Use caseUse it to drive graph-guided exploration of large monorepos before the agent writes patches.

graphpythoncodingresearch

repoGitHub

SWE-bench↗

SWE-bench

Canonical software-engineering benchmark and harness for issue-to-patch agent evaluation across real GitHub repositories.

Use caseUse it to measure pass@1 of your coding harness on verified GitHub issues with official Docker runners.

benchmarkswepythoneval

repoGitHub

SWE-ReX↗

SWE-agent team

Sandboxed remote execution layer for AI agents that keeps the same API across local shells, Docker, Modal, Fargate and parallel sessions.

Use caseUse it to run hundreds of coding-agent trajectories in parallel without rewriting agent logic for each backend.

sandboxparallelswe-benchpython

repoGitHub

Terminal-Bench↗

harbor-framework

Benchmark measuring agents on complicated real terminal workflows with Harbor as the official runner.

Use caseUse it to score shell-native coding agents on multi-step terminal tasks with concurrent Harbor jobs.

terminalbenchmarkevalshell

harnessGitHub

VoltAgent↗

VoltAgent

Open-source TypeScript agent engineering platform with core runtime, workflows, supervisors, MCP tools, memory adapters, guardrails, and a paired observability console.

Use caseUse it to spin up typed multi-agent teams with durable memory and production evals from a single create-voltagent-app scaffold.

typescriptmulti-agentmcpobservability

harnessGitHub

agent-harness↗

adambossy

Provider-agnostic modular Python agent harness with Protocols for models, tools, sessions, and sandboxes plus async typed core under 3k LOC.

Use caseUse it to assemble a custom loop that plugs Anthropic, OpenAI, Modal sandboxes, or Redis sessions without god-classes.

pythonmodularprovider-agnosticsandbox

harnessGitHub

Agentic Harness↗

moortekweb-art

Self-hosted completion gate that wraps coding agents with independent verification, durable evidence, CLI, and local GUI before reporting done.

Use caseUse it to force an external check and report.md before any agent can claim a goal is finished across compatible CLIs.

verificationgatecompletionself-hosted

repoGitHub

Agentic Harness Engineering (AHE)↗

china-qijizhifeng

Observability-driven system that automatically evolves coding-agent harness components such as prompts, tools, middleware, and memory while holding the base model fixed.

Use caseUse it to iterate harness configs over evaluate-analyze-improve loops and freeze transferable components that lift Terminal-Bench scores.

harness-engineeringobservabilityevolutioneval

harnessGitHub

agentic-sandbox↗

jmagly

Self-hostable runtime for persistent autonomous coding agents using KVM-isolated VMs or rootless containers with A2A protocol, dashboard, and virtiofs storage.

Use caseUse it to run long-lived agent sessions on your own hardware with signed AgentCard discovery and mission dispatch without a hosted control plane.

sandboxkvmself-hostedpersistent

harnessGitHub

AgentTier↗

agenttier

Kubernetes-native sandbox platform providing isolated persistent environments for AI agents and developers via CRDs with gVisor options and interactive access.

Use caseUse it to provision secure sandboxes for coding agents or teams with declarative lifecycle, network isolation, and multi-agent orchestration.

kubernetessandboxcrdisolation

repoGitHub

Blaxel Sandbox↗

blaxel-ai

Open-source microVM sandbox templates and hub for persistent agent compute with standby resume, MCP tools, filesystem, and process APIs.

Use caseUse it to give agents dedicated Linux environments that resume in tens of milliseconds while keeping full state across idle periods.

sandboxmicrovmmcppersistent

toolGitHub

Codewhale↗

Hmbown

Open-source Rust terminal coding agent with multi-model support, fleets, MCP, hooks, approval modes, snapshots, and local-first extensibility.

Use caseUse it to coordinate agent teams on repo tasks with explicit plan or full-access modes and undoable workspace restores.

rustclifleetmcp

toolGitHub

Codey↗

its-ahoh

Multi-agent workbench that orchestrates Claude Code, Codex, OpenCode, and Pi from a native macOS app, chat platforms, or voice with per-project workspaces.

Use caseUse it to run parallel agents on the same prompt for comparison or define worker teams with flow graphs and messaging channels.

workbenchmulti-agentmacosparallel

harnessGitHub

HAR↗

os-factory

Open agent harness CLI plus MCP that runs coding agents in isolated worktrees with deterministic launch, verify, and teardown stages.

Use caseUse it to turn any repo into verified software-factory slots that wrap Claude Code, Cursor, or Codex with project-native checks.

worktreeverifymcpcli

harnessGitHub

Harness↗

majiayu000

Rust control plane for fleets of parallel coding agents with orchestration, policy enforcement, cross-agent review, and observability.

Use caseUse it to assign work, police permissions, and run independent reviews across Claude Code or Codex adapters in long-running fleets.

rustcontrol-planefleetpolicy

toolGitHub

jcode↗

1jehuang

High-performance Rust coding agent harness optimized for low RAM, fast boot, semantic memory graphs, side panels, and native swarm collaboration across sessions.

Use caseUse it to run dozens of parallel coding sessions on limited hardware with automatic conflict notification and memory recall.

rustharnessswarmmemory

harnessGitHub

OpenHarness↗

maisieyang

Local-first Python control plane for coding agents featuring Default, Plan, externally judged Goals, sandboxed execution, durable context, plugins, and evals.

Use caseUse it to drive REPL sessions with independent judges that decide continue, complete, or pause based on artifacts rather than agent claims.

pythoncontrol-planejudgesandbox

toolGitHub

openteams↗

openteams-lab

Local-first AI desktop app that plans, builds, and ships with a controllable team of coding agents including many popular CLIs plus a bundled CLI.

Use caseUse it to assign roles across Claude Code, Codex, Pi, and others inside one workspace with budget caps and reviewer loops.

desktopmulti-agentlocal-firstorchestration

harnessGitHub

Pi↗

earendil-works

Minimal extensible coding agent harness with unified multi-provider LLM API, agent core loop, TUI, skills, extensions, and session persistence.

Use caseUse it to build or extend a lean coding CLI that stays small at core while adding TypeScript packages for custom tools and themes.

harnesscliextensiblemulti-provider

repoGitHub

remote-swe-agents↗

aws-samples

Self-hosted fully open-source autonomous SWE agent example on AWS that works in dedicated cloud environments and opens PRs.

Use caseUse it to run laptop-free coding agents that clone, edit, test, and submit pull requests inside isolated AWS workspaces.

awsautonomousswecloud

repoGitHub

Sandboxer↗

hyperterse

Unified client libraries in Go, Python, and TypeScript that talk directly to E2B, Daytona, Blaxel, Runloop, Fly, or local Docker sandboxes.

Use caseUse it to switch sandbox providers behind one mental model for create, exec, filesystem, and teardown without rewriting agent code.

sandboxmulti-providersdkabstraction

harnessGitHub

SWE Forge↗

joacod

Portable opt-in workflow orchestration that sits above coding harnesses to turn tickets into bounded inspect-plan-implement-verify-review deliveries.

Use caseUse it to add evidence-backed SOLO or SUBAGENTS topologies over Pi, OpenCode, or experimental Claude Code adapters without replacing the base harness.

workfloworchestrationverifyharness-agnostic

harnessGitHub

SWE-AF↗

Agent-Field

Autonomous software engineering fleet runtime that spins up planners, coders, reviewers, and testers to ship production-grade PRs from a single goal call.

Use caseUse it to orchestrate multi-repo builds with dependency scheduling, git worktrees, and adaptive factory control for end-to-end delivery.

fleetorchestrationswemulti-agent

repoGitHub

SWE-agent↗

SWE-agent

LM-driven harness built for SWE-bench that provides edit state, command execution, and an issue-focused loop as a reference agent-computer interface.

Use caseUse it to clone a battle-tested issue-to-PR agent stack and adapt the YAML config for custom benchmarks or cybersecurity tasks.

swe-benchharnessresearch-originpython

harnessGitHub

TrueForge↗

TrueFoundry

Open-source agent harness runtime that handles model calls, MCP tools, skills, sandboxing, approvals, context compaction, and session state with chat UI plus TypeScript SDK.

Use caseUse it to deploy cost-controlled multi-step agents locally or hosted while swapping any model provider and MCP servers.

harnessmcpsandboxsdk

harnessGitHub

Agent Sandbox↗

Kubernetes SIGs

Kubernetes CRD and controller for isolated, stateful, singleton workloads tailored to AI agent runtimes and RL, with warm pools and stable identity.

Use caseUse it to declare and manage long-lived agent sandboxes on any K8s cluster with pause/resume and template claims.

kubernetessandboxcrdinfra

harnessGitHub

Agent Security Harness↗

msaleme

Adversarial testing harness with hundreds of executable protocol-level tests for MCP, A2A, and governance controls.

Use caseUse it to CI-gate agent endpoints by actively probing for policy bypass and tool poisoning.

securityevalmcp

toolGitHub

Agenta↗

Agenta-AI

Open-source workspace for building, versioning, and collaborating on agents and automations with MCP and self-hosting.

Use caseUse it to prototype and share agent workflows as a team with prompt and skill management.

workspacemcpself-hosted

harnessGitHub

AgentTeams↗

agentscope-ai

Collaborative multi-agent OS using Matrix rooms for transparent human-in-the-loop coordination across heterogeneous runtimes.

Use caseUse it to run mixed OpenClaw, Hermes, and other workers in shared rooms with file exchange and audit.

multi-agentmatrixorchestration

toolGitHub

AIO Sandbox↗

agent-infra

Single Docker container packing browser, shell, filesystem, MCP servers, VSCode Server, and Jupyter for unified agent environments.

Use caseUse it to give coding or computer-use agents one shared sandbox with VNC, CDP, and MCP endpoints.

sandboxdockermcpbrowser

harnessGitHub

Chorus↗

community

CLI harness pattern for multi-LLM peer review before shipping code, listed among rising terminal agent tooling.

Use caseUse it to add a multi-model review gate in front of any coding agent commit flow.

reviewmulti-llmcli

harnessGitHub

Coze Loop↗

coze-dev

Full-lifecycle agent optimization platform covering development, debugging, evaluation, and monitoring.

Use caseUse it to instrument and iterate on agent workflows with playgrounds, evals, and production monitoring.

evalobservabilityoptimization

toolGitHub

Crush↗

Charmbracelet

Go-native terminal coding agent with polished TUI, LSP intelligence, multi-provider switching mid-session, MCP extensibility, and session persistence.

Use caseUse it to run provider-agnostic agentic coding sessions directly in the terminal with LSP-backed edits and MCP tools.

clituigomcp

repoGitHub

CubeSandbox↗

Tencent Cloud

RustVMM/KVM microVM sandbox service with sub-60ms boot, hardware isolation, under 5MB overhead, and E2B SDK drop-in compatibility.

Use caseUse it to self-host high-density, hardware-isolated code execution backends for agent tool calls.

sandboxmicrovme2brust

repoGitHub

Headroom↗

community (via best-of lists)

Content-aware compression layer for tool outputs, logs, and RAG chunks that claims large token reductions for coding agents.

Use caseUse it to shrink context before it hits the model while preserving answer quality on long agent runs.

contextcompressiontokens

toolGitHub

Kimi Code CLI↗

Moonshot AI

Single-binary terminal coding agent with fast TUI startup, skills, MCP, and ACP IDE integration, model-agnostic beyond Kimi defaults.

Use caseUse it to install a zero-Node coding agent that reads, edits, shells, and plans inside any repo.

clicoding-agentbinary

toolGitHub

LiteLLM↗

BerriAI

Unified interface and proxy for 100-plus LLMs with routing, caching, budgets, and agent SDK gateways.

Use caseUse it as the model router and spend control plane in front of any custom harness.

proxyroutingmulti-provider

harnessGitHub

metaharness↗

ruvnet

Scaffold that generates a focused, branded agent harness with npx CLI, MCP server, scoped memory, skills, and witness-signed releases for multiple host runtimes.

Use caseUse it to spin up a repo-specific harness that drops into existing coding agents with governance and provenance.

meta-harnessscaffoldmcpcli

harnessGitHub

Mission Control↗

builderz-labs

Self-hosted control plane for dispatching tasks, reviewing runs, tracking spend, and operating multiple agent runtimes.

Use caseUse it to operate fleets of coding agents with observability, spend controls, and task queues.

control-planeopsobservability

toolGitHub

NanoClaw↗

nanocoai

Lightweight container-isolated AI assistant inspired by larger claw-style agents, designed for readable code and secure defaults.

Use caseUse it to deploy per-agent containers with shared rooms while keeping the codebase small enough to audit.

containersecurityassistant

toolGitHub

Qwen Code↗

QwenLM / Alibaba

Open-source terminal coding agent with auto-memory, skills, sub-agents, teams, MCP, plan mode, and multi-protocol support optimized for Qwen coder models.

Use caseUse it to run headless or interactive agentic coding workflows with free OAuth tiers and IDE plugins.

clicoding-agentopen-source

toolGitHub

Roo Code↗

RooCodeInc

VS Code and Cursor extension in the Cline lineage with approval-gated modes, strong MCP support, and custom agent modes.

Use caseUse it for plan-then-act coding inside the editor with per-step gates and MCP tools.

idemcpextension

harnessGitHub

Strands Agents↗

strands-agents

Open-source Python and TypeScript SDK for building production agent loops with lifecycle controls, MCP, memory, multi-agent patterns, guardrails, and evals.

Use caseUse it to replace hand-rolled agent loops with a portable, model-agnostic harness you control end-to-end.

sdkpythontypescriptmcp

toolGitHub

Trae Agent↗

ByteDance

Research-friendly Python CLI agent for software engineering with modular architecture and multi-LLM support.

Use caseUse it to prototype SWE-bench style loops or modular coding agents without heavy product shells.

cliresearchpython

toolGitHub

ZeroClaw↗

zeroclaw-labs

Single Rust binary agent runtime with multi-channel support, provider plugins, supervised autonomy, and OS-level sandbox options.

Use caseUse it to run a low-overhead personal or team agent across Discord, Telegram, and CLI with policy gates.

rustruntimemulti-channel

harnessGitHub

agent-harness↗

SUNRNEHUI

Plan-native execution harness adding intent-to-contract synthesis, durable handoff, and evidence-based acceptance.

Use caseUse it to add portable contracts and audit gates across Codex, Claude Code, or other file-and-shell agents.

plancontractsreliabilityskills

harnessGitHub

agentOS↗

rivet-dev

Lightweight WASM and V8 isolate OS library that runs agents inside your process with millisecond cold starts and direct host bindings.

Use caseUse it to embed Pi or other ACP agents as in-process VMs with granular permissions instead of spinning full sandboxes.

wasmsandboxruntimeacp

harnessGitHub

Agno↗

agno-agi

Framework and AgentOS runtime for building, serving, and managing agent platforms with UI control plane.

Use caseUse it to own your full agent stack including sessions, memory, traces, and MCP in your own cloud.

platformruntimecontrol-planepython

repoGitHub

AIOS↗

agiresearch

AI Agent Operating System with kernel and SDK for scheduling, context, memory, tools, and computer-use sandboxes.

Use caseUse it to treat agents as first-class OS processes with shared resource management and deployment modes.

oskernelsandboxmulti-agent

toolGitHub

Chrome DevTools MCP↗

ChromeDevTools

Official MCP server exposing full Chrome DevTools for automation, performance traces, network, console, and debugging.

Use caseUse it to let an agent inspect LCP, take heap snapshots, or drive live Chrome sessions during coding tasks.

mcpdevtoolsbrowserperformance

toolGitHub

Composio↗

ComposioHQ

Tool layer with 1000+ integrations, auth, search, and sandboxed workbench so agents stop reinventing OAuth.

Use caseUse it to drop authenticated toolkits into any agent harness for Gmail, GitHub, Slack, and more.

toolsintegrationsauthmcp

harnessGitHub

Deep Agents↗

langchain-ai

Batteries-included opinionated agent harness on LangGraph with planning, filesystem tools, sub-agents, and context management.

Use caseUse it to spin up a production-ready long-horizon research or coding agent and override only the pieces you need.

langgraphharnesssubagentspython

harnessGitHub

dmux↗

standardagents

Dev agent multiplexer that creates git worktrees and tmux panes for parallel coding agents.

Use caseUse it to launch isolated agent sessions per task then merge or PR the results from a single board.

worktreestmuxorchestrationparallel

repoGitHub

E2B Desktop↗

e2b-dev

Open-source virtual desktop sandbox for computer-use agents with graphical environment and streaming.

Use caseUse it to give agents a full isolated desktop for GUI automation and secure code execution.

sandboxcomputer-usedesktope2b

repoGitHub

Graphiti↗

getzep

Framework for building temporal knowledge graphs that track changing facts with provenance for agent memory.

Use caseUse it to give agents a real-time context graph that invalidates stale facts and supports hybrid retrieval.

memoryknowledge-graphtemporalagents

harnessGitHub

Harness Kit↗

deepklarity

Multi-agent orchestration CLI plus task board with TDD-first patterns, RCA, and cost-aware delegation.

Use caseUse it to decompose specs into dependency graphs, route tasks to cheapest capable agents, and keep evidence trails.

orchestrationpatternstask-boardcli

toolGitHub

Kit↗

speakeasy-api

Coding agent runtime with one compose tool, ACP server, A2A, and subagent orchestration in a static binary.

Use caseUse it as a concise daily-driver harness that reloads skills and MCP dynamically and hosts other agents over ACP.

runtimeacpcomposecli

toolGitHub

Letta Code↗

letta-ai

Memory-first stateful coding agent that persists identity and long-term memory across sessions and models.

Use caseUse it to run coding agents that learn from experience and retain context without prompt stuffing.

memorystatefulcoding-agentletta

toolGitHub

mcp-use↗

mcp-use

TypeScript framework for building MCP servers and apps rebuilt for the stateless 2026 MCP spec.

Use caseUse it to ship high-throughput MCP servers with inspector, HMR views, and headless screenshot debugging for agents.

mcptypescriptserversapps

harnessGitHub

OpenAI Agents SDK↗

openai

Lightweight provider-agnostic framework for multi-agent workflows with handoffs, guardrails, and tracing.

Use caseUse it to compose specialist agents with structured handoffs and run them against any tool-calling LLM.

multi-agentsdkpythontracing

harnessGitHub

PraisonAI↗

MervinPraison

Fast multi-agent workforce framework with planning, memory, RAG, dashboards, and multi-provider support.

Use caseUse it to spin up autonomous agent teams with low-latency orchestration for production workflows.

multi-agentworkforcepythonmcp

toolGitHub

Pydantic AI↗

pydantic

Typed Python AI SDK and agent framework with structured outputs, multi-model support, and MCP integration.

Use caseUse it to build type-safe agent loops with validated I/O and Logfire observability for production services.

typedpythonmcpagents

repoGitHub

smolagents↗

huggingface

Barebones Python library for code-as-action agents that write and execute Python in sandboxes like E2B.

Use caseUse it to prototype multi-step agents that compose tools via real code rather than JSON tool calls.

code-agentpythonsandboxhuggingface

toolGitHub

Stagehand↗

browserbase

SDK for browser agents built on Playwright with natural language actions, self-healing, and multi-language support.

Use caseUse it to give coding or research agents reliable web navigation and extraction without brittle selectors.

browserplaywrightagent-sdktypescript

toolGitHub

VT Code↗

vinhnx

Rust terminal coding agent and harness with sandboxed tools, durable sessions, MCP, skills, and multi-provider support.

Use caseUse it to run long autonomous coding loops from a TUI or headless mode with built-in verification and worktree isolation.

rusttuicoding-agentmcp

harnessGitHub

Agenvoy↗

agenvoy

Self-hosted AI agent harness in a single Go binary. Writes, sandbox-tests, and repairs its own code. No Electron, no account.

Use caseUse it as a local coding worker you can scp onto a box and run unattended against a failing test suite.

goself-hostedself-repair

toolGitHub

cmux↗

manaflow-ai

Open-source Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents.

Use caseUse it as the terminal surface when you are running a swarm of CLIs and need to see which one just finished.

terminalmacosnotifications

harnessGitHub

Containarium↗

FootprintAI

Open-source agent runtime with SSH-native isolation, eBPF egress policy, Kubernetes and LXC backends.

Use caseUse it to run untrusted coding agents with real network policy instead of hope.

isolationebpfruntime

toolGitHub

context-mode↗

mksglu

Context-window surgery for coding agents. Sandboxes tool output so the model sees the signal instead of a 40k-token log.

Use caseUse it when your agent keeps blowing the window on build logs and you need the loop to survive a real compile.

contexttool outputcoding agents

toolGitHub

CUA↗

trycua

Open-source computer-use 2.0: drivers, cross-OS fleets, and benchmarks for training and evaluating desktop agents.

Use caseUse it to give a coding agent a real desktop when the job is a GUI installer, not an API.

computer usedesktopbenchmarks

harnessGitHub

DeepCode↗

HKUDS

Open agentic coding from HKU: agent harness, loop engineering, multi-agent orchestration. Academic lab software that ships as a repo you run.

Use caseUse it when you want a research harness with a real coding loop, not a chatbot with extra steps.

researchharnessmulti-agent

toolGitHub

Ghostex↗

maddada

Rust and GPUI native agent CLI manager for macOS. Ghostty terminals plus Codex-app UX, without Electron.

Use caseUse it to manage a stack of native agent CLIs in Ghostty instead of a webview IDE.

rustmacosterminal

harnessGitHub

graff↗

justrach

Fast agentic coding harness in Zig: multi-provider, MCP, workflows.

Use caseUse it when you want a coding loop with systems-language latency, not a Node daemon.

zigharnessmcp

harnessGitHub

Herdr↗

herdrdev

The runtime your coding agents live on. Not another chat wrapper: a place agents persist, resume, and share a machine.

Use caseUse it when you want agents to survive a laptop sleep and pick up the same checkout, secrets, and tools.

runtimepersistenceagents

harnessGitHub

Ironcurtain↗

provos

Secure runtime for autonomous agents. Policy from plain-English constitutions.

Use caseUse it when you will not give a coding agent root and still want it to act.

securityruntimepolicy

harnessGitHub

LoopX↗

huangruiteng

A long-horizon control plane that keeps coding agents on durable, governed work instead of one-shot chats. Power users treat it as the supervisor, not another model.

Use caseUse it to keep an overnight refactor alive across tool crashes, with a human gate on the risky steps.

control planelong-horizonorchestration

harnessGitHub

mcp-agent↗

lastmile-ai

Build effective agents with Model Context Protocol and small workflow patterns.

Use caseUse it to compose MCP servers into a durable agent without standing up a full IDE plugin.

mcpruntimeworkflows

repoGitHub

mini-SWE-agent↗

SWE-agent

The 100-line AI agent from the Princeton SWE-agent line. Research origin, radical simplicity, still beating bloated wrappers on SWE-bench-class work.

Use caseUse it to throw a GitHub issue at a 100-line loop you can actually read, fork, and instrument.

researchswe-benchminimal

repoGitHub

Mnemon↗

mnemon-dev

LLM-supervised persistent memory for agents: graph recall, cross-session knowledge, no vector-store cargo cult.

Use caseUse it to give a coding agent a graph of the last two weeks of decisions so it stops re-deriving your architecture.

memorygraphagents

harnessGitHub

oh-my-agent↗

first-fluke

A multi-agent harness that checks the work by artifacts, not vibes. Stop-hooks verify diffs, tests, and files before the run is allowed to claim success.

Use caseUse it to stop a coding agent from declaring done when the test file was never written.

verificationstop-hooksharness

harnessGitHub

oh-my-claudecode↗

Yeachan-Heo

Teams-first multi-agent orchestration for Claude Code. Not Claude Code itself: the swarm layer people bolt on.

Use caseUse it to run a team of Claude Code workers on one repo with a shared plan file.

orchestrationteamsclaude-code-layer

toolGitHub

oh-my-pi↗

can1357

A coding agent with the IDE wired in. Created New Year's Eve 2025, still being pushed daily.

Use caseUse it when you want the agent and the editor to share one process instead of a plugin talking to a CLI.

idecoding agentopen source

harnessGitHub

Omnigent↗

omnigent-ai

Open-source meta-harness: one orchestrator that fans work across several coding agents. Born June 2026, already the loudest new control plane on GitHub.

Use caseUse it to run three different coding agents on the same ticket and merge the first one that lands a green test.

meta-harnessorchestrationopen source

toolGitHub

open-computer-use↗

e2b-dev

Computer-use agents on open models plus an E2B desktop sandbox. The open alternative to a vendor's computer-use API.

Use caseUse it to let an open model click through a desktop app inside a throwaway VM.

computer usesandboxopen models

toolGitHub

Orca↗

stablyai

An ADE for a fleet of parallel agents. Run any coding agent against your repo in parallel panes instead of one blessed CLI.

Use caseUse it to fan the same failing test across four agents and keep only the patch that compiles.

fleetadeparallel

repoGitHub

OSWorld 2.0↗

xlang-ai

Long-horizon computer-use benchmark. The eval serious desktop-agent repos cite.

Use caseUse it to grade your own computer-use agent on real desktop tasks before you trust it on a laptop.

benchmarkcomputer useeval

harnessGitHub

Warren↗

jayminwest

Treats coding agents as infrastructure, not terminal sessions. Isolation, lifetimes, and scheduling so a fleet of agents looks like a job queue.

Use caseUse it to fire 20 isolated agent jobs against a monorepo without them trampling each other's working trees.

sandboxfleetisolation

toolGitHub

Whip↗

context-labs

Fast coding-agent harness in Go. Tool-use loop, bubbletea TUI, provider-routable models. Created August 2026.

Use caseUse it as a Go TUI coding agent when you want to swap models without swapping the loop.

gotuicoding agent

harnessGitHub

CLI Agent Orchestrator↗

awslabs

AWS Labs multi-agent orchestration for AI coding CLIs. The interesting part is the coordinator, not the branded CLIs it wraps.

Use caseUse it to run two vendor CLIs as workers under one policy instead of alt-tabbing between terminals.

orchestrationcliaws