Orchestration
Compose and control multi-step LLM pipelines.
Desktop agent IDE for fleets of coding agents: each task gets a worker with its own workspace and agent CLI, while a project orchestrator plans work and handles CI fixes, conflicts and reviews.

Open-source control plane that runs AI agents as microservices: write plain Python/Go/TS functions, get REST endpoints with routing, queues, retries, memory and tracing — one laptop to 10k agents.

Self-hosted collaboration layer that turns local coding agents (Claude Code, Codex, OpenCode) into an always-on "AI company" — per-agent email, org chart, kanban, shared memory.

A fully autonomous 'AI company' on your own PC: 14 expert-modeled agents ideate, decide, code, deploy and market 24/7 — driven by Claude Code or Codex CLI, with a local dashboard.
Google's declarative runtime for agent workloads on Kubernetes: Task, Workspace and Model manifests run each agent sandboxed on Agent Substrate, with suspend/resume and ax ssh.

Open-source platform unifying AI agent orchestration with classic workflow automation — visual builder, 200+ integration components, self-hosted via Docker. Apache 2.0 + EE split.
Group-chat orchestration for coding agents: Claude Code, Codex, ChatGPT Web and others in one durable group with an append-only ledger, read receipts, and Web/IM/mobile ops.

Terminal-first orchestrator for issue-driven AI coding-agent runs — polls Linear/GitHub, runs Codex/OpenCode in git worktrees with retries and verification. Go/Charm rebuild of OpenAI's Symphony.

Orchestrate role-playing, autonomous AI agents that collaborate on tasks.
LangChain's batteries-included agent harness on LangGraph — planning, sub-agents with isolated context, filesystem, shell, skills, human-in-the-loop and persistent memory out of the box.
DeepSeek's open agent harness (`dsh`): everything is a plugin, on the Cordis composability runtime, with a local web UI one npx away. Developer preview, MIT, moving fast.
Graph-engineering runtime where TypeScript owns control flow and replaceable coding-agent CLIs — Codex, Claude Code, Pi — do the semantic work inside each node. Pilot for DeerFlow 3.0.

Program — don't prompt — your language models. Compile declarative pipelines into optimized prompts.
Production JavaScript framework for agentic workflows: one sentence becomes a dependency-aware multi-agent plan that runs in browser, Node, or extension — with pause/resume and snapshot recovery.
Rust 'software factory' for coding agents: define the SDLC as a graph, agents execute it through verification gates, you intervene only at the stages that matter. Server, runs board, sandboxes.

Semantic DataFrames: PySpark-style select, filter and join alongside AI operators — extract, classify, summarize, embed, semantic join — compiled on an engine built for inference.

The 55k-star visual builder for LLM apps and agents — drag-and-drop chatflows and Agentflows, hundreds of nodes, self-hostable Node.js. Now ARCHIVED upstream (see 'Future of Flowise').

Coordination protocol for parallel coding agents above Git: agents declare intent in a shared SQLite store, and a deterministic detector flags plan collisions before code is written.

Hierarchical agent loops: nodes iterate toward a goal in their own git worktree and spawn children for subtasks — the tree grows to fit the problem. Hard caps, SQLite run log, live TUI.
A multi-agent software factory: describe a task, agents plan (PROMPT.md), build, review and merge in isolated worktrees — kanban + graph board, missions, agent chat rooms, any model. Early preview.

Self-hosted Apache-2.0 reference implementation of the Unified Harness Protocol: one OpenAI-Responses-style API running Codex, Claude Code, Hermes, Pi and DSH with sessions, streaming, files, traces.

Local-first desktop workbench for orchestrating coding agents: per-repo workspaces, task dispatch, live status and runnable actions — GUI plus CLI, Apache-2.0.

Agent multiplexer for your terminal: every Claude Code/Codex session in real panes — blocked/working/done at a glance, detach and reattach over SSH, plus a socket API agents drive themselves.

YC-backed multi-agent harness for production: state an objective and the runtime compiles a graph DAG of specialized agents — role-based memory, crash recovery, cost limits, human-in-the-loop.

ZJU's self-hosted enterprise AgentOS on AgentScope 2.0: domain ontology as a control plane for agents, plus RAG, sub-agents, MCP, skills, sandbox, memory and approval-gated self-evolution.
NVIDIA's object-oriented agent framework: an agent is a Python class — fields are state, docstrings are prompts, and a `...` method body becomes an LLM loop that acts by writing Python.
Build stateful, multi-actor LLM apps as graphs — durable execution, human-in-the-loop, streaming.
LobeChat's 80k-star pivot: from chat UI to 'Chief Agent Operator' — hire, schedule and supervise a team of agents running 7×24, self-hosted via Docker or Vercel, plugin ecosystem carried over.
Reference repo plus npm CLIs (loop-init/audit/cost) for loop engineering: designing scheduled, gated control loops that prompt and orchestrate AI coding agents — Grok, Claude Code, Codex — over time.

Self-hosted Java agent platform: ReAct plus plan-and-execute 'digital employees' with an LLM Wiki knowledge layer, skills/MCP/ACP tools, approval-gated actions and eight IM channels in one JAR.

The original "AI software company" multi-agent framework — role-assigned agents (PM, architect, engineer) turn a one-line requirement into PRD, design, and code.
Open-source meta-harness over Claude Code, Codex, Cursor, OpenCode, Hermes, Pi and custom agents: swap harnesses without rewriting, enforce policies and sandboxes, follow sessions from any device.
CopilotKit's self-hosted AI coworkers: each gets its own computer — a real browser with logins, files, granted tools — with every action decided before it runs and recorded after. Any AG-UI agent.

PyTorch-shaped multi-agent framework: Session is the tensor, Agent the layer, Workflow the module — plus a v2 durable runtime with checkpoints, leases, an effect ledger and human interrupts.
Open-source control plane for running fleets of heterogeneous AI agents as a "company" — bring your own agent, assign goals, org charts, budgets, governance, and an audited ticket system.
AI-native Envoy-based proxy for agentic apps: agent orchestration via a 4B routing model, smart LLM routing, guardrail filter chains and zero-code OTEL traces. Rust, framework-agnostic.

Multiplayer agent harness for startups: every employee gets a scoped workspace — memory, files, keychain, crons, sandbox — in Slack and web, with Pi/OpenCode/Codex/Claude Code swappable underneath.

ruvnet's 65k-star 'agent meta-harness': multi-agent swarms, adaptive memory and RAG layered over Claude Code, Codex and Hermes — npx ruflo, a UI beta, and a sprawling plugin ecosystem.
Scale AI's open agent platform: scaffold agents with a CLI, run them behind the ACP protocol with a dev UI, and graduate from sync chat to durable Temporal-backed long-running workflows.

Runtime substrate that records agent runs as reversible, Git-like execution traces — meta-agents can observe, fork, replay and revert any run before outputs are applied or released.

Visual workspace to build, deploy and orchestrate AI agents — 1,000+ integrations, knowledge bases, built-in tables and files, schedules and run monitoring. Self-host via npx simstudio or Docker.

Speculative programmatic tool calling: while the model is still streaming a code block, the harness launches the tool and sub-LLM calls it is about to make, so blocking calls overlap generation.

Multi-agent terminal collaboration for AI CLIs: a manager, workers and an inspector — Claude Code, Gemini, Codex, OpenCode — coordinating through one-shot shell commands and SQLite. No daemon.
Claude Code plugin that turns a feature spec into a reviewed PR through a 5-agent pipeline — PA → SWE → Tester → PR-Reviewer → On-Call — with exactly two human gates.

State-machine guardrails for AI agents: define workflow phases once and only that phase's tools unlock — enforced across Claude Code, Codex, Cursor, opencode and Pi. Rust.
TrueFoundry's open agent harness: the runtime loop — model calls, MCP tools, SKILL.md packs, sandboxing, approvals, compaction — behind a chat UI, HTTP API, TypeScript SDK and embeddable UI.

wt: the Rust git-worktree CLI built for parallel AI agents - worktrees addressed by branch name, `wt switch -c -x claude feat` creates one and starts an agent, plus hooks, list-with-status and merge.

Executor–verifier orchestration for code changes: a conductor classifies the task, an executor works in an isolated worktree, and a separate verifier must reproduce the evidence — looped to approval.