AI Agent Frameworks

hermes-agent261.0k★

Hermes is Nous Research's open-source autonomous agent. It builds skills from experience, remembers them across sessions, and connects to Telegram, Discord, Slack, WhatsApp, Signal, and email out of the box. It drives more than 300 models through OpenRouter, OpenAI, Anthropic, Hugging Face endpoints, or Nous Research's own portal. MIT licensed. Install is one curl command on Linux, macOS, WSL2, or Termux. After hermes setup, point it at any provider; switching models is a single CLI flag with no code changes. It runs on a $5 VPS or a GPU cluster, and releases land several times a month. Nous now sells subscriptions alongside the free agent, which is the change worth knowing about. There is still a free tier, and the software itself has no paid edition or feature gate. The paid plans are model access: Plus at $20 a month, Super at $100, and Ultra at $200, each bundling 300+ models and the hosted tools Hermes calls into one bill instead of four provider accounts. Each tier carries a monthly credit allowance in the neighbourhood of what you pay for it. Solo builders can ignore all of it and bring an OpenRouter key. Anyone tired of managing separate provider keys has a reason to look. The catch is that it is research-y. Nous is an AI research lab, not a SaaS company. Docs are dense, support is community-driven, and self-improving claims always come with caveats. Treat it as an experiment you are running, not a production-grade agent you are deploying.

dify160.5k★

Dify is a visual builder for AI apps: chatbots, RAG over your documents and agent workflows on a visual canvas, each exposed as an API. It works with hundreds of hosted and local models. Picture n8n rebuilt around LLMs. The Community Edition is free to self-host. Self-hosting starts with docker compose up -d on a box with 2 cores and 4 GiB of RAM, but the default stack is about 15 containers: API, workers, web, Postgres, Redis, code sandboxes, a plugin daemon, SSRF proxies, Nginx and Weaviate. Read release notes before upgrading: 1.17.1 required a staged manual Weaviate upgrade or vector search could silently break. Dify Cloud has a free Sandbox tier. Professional is $59 per workspace a month for 3 members; Team is $159 a month for 50. Self-hosted Community is one workspace, and SSO is Enterprise only, custom priced. Solo: self-host free. Small teams: self-host, or Professional to skip the ops. Larger orgs: Enterprise once you need SSO. The catch is the license: Apache 2.0 plus conditions. No multi-tenant hosting and no removing the Dify logo from the frontend without a commercial license. Security has been rough too, with a run of cross-tenant bugs through 2026. Patch fast.

langchain149.1k★

LangChain is the glue layer for LLM apps: one standard interface for models, vector stores and tools, plus create_agent, a small harness that builds an agent from a model, tools and a prompt. Swap OpenAI for Anthropic or local Ollama without a rewrite. LangChain, LangGraph and Deep Agents are all MIT and free. There's nothing to host. uv add langchain and you're writing code. The ops work is upgrades: patches can land a few times a week, though since 1.0 breaking changes wait for major versions. Still on 0.3? Its maintenance window closes in December 2026. The paywall is LangSmith, their hosted tracing, evals and deployment platform. Developer is free for one seat and 5k traces a month. Plus is $39 per seat per month with 10k traces, then usage billing. Self-hosted LangSmith is Enterprise only. Solo: free. Small teams: Plus, or send traces to Langfuse instead. Large teams: Enterprise for SSO or self-hosting. The catch: a single chat call is simpler with the provider SDK, and when a chain misbehaves you debug LangChain's internals. Security too. langchain-core has shipped a steady run of advisories, including a critical serialization bug that could leak secrets (CVE-2025-68664). Pin versions and patch fast.

odysseus95.2k★

Odysseus is a self-hosted AI workspace: chat with local or hosted models, autonomous agents with tools and MCP, deep research, blind side-by-side model comparison, a writing editor, an email inbox with triage and reply drafts, notes, tasks and calendar sync. Its Cookbook looks at your hardware, recommends models that fit, then downloads and serves them for you through vLLM, SGLang, llama.cpp, MLX or Ollama. It's AGPL-3.0. Docker Compose gets it running at localhost:7000, with NVIDIA and AMD GPU overlays; pin the immutable image tag rather than latest. On Apple Silicon, Docker can't reach the GPU, so use the native install. Its own threat model says to treat it like an admin console: a logged-in admin can run shell commands, read and write files and send email. Keep auth on and never expose it directly to the internet. No paid tier; your costs are hardware and any hosted-API tokens. Solo tinkerers with a decent GPU get a lot for free. Small trusted teams on a private network can share it. Anything bigger needs a security review first. AGPL means that if you modify it and let others use it over a network, you owe them your source. The catch: it's young, the issue tracker is enormous, and it touches your email and your files. Without a capable GPU or plenty of RAM you're limited to small local models.

AutoGen61.7k★

AutoGen is Microsoft's framework for building multi-agent AI systems, where several agents with different roles and tools work together, or alongside a person, to finish a task. You define the agents and AutoGen handles how they talk, call tools, run code in a sandbox, and pause for your approval. The code is MIT, the docs and examples are CC-BY-4.0, and all of it is free. Here is the part that matters before you build on it: AutoGen is in maintenance mode. Microsoft named microsoft/agent-framework as the successor and steers new users there. AutoGen still runs and the v0.7 line is stable, but its Python packages have not shipped a release since September 2025 while the successor ships roughly every week. Contributions are limited to bug fixes, security patches, and docs. Already running it in production? You are fine for now, but put a migration to microsoft/agent-framework on the roadmap instead of treating this as permanent. Picking a framework today: start with the successor, or look at crewAIInc/crewAI and langchain-ai/langgraph, which most people find easier for simpler workflows. Solo and small teams: still a good way to learn the patterns, you are just learning a frozen API. The catch is that, plainly: Microsoft stopped developing this. The pile of existing tutorials makes it look like the safe default, and maintenance mode means no fixes for new model behaviors and no new capabilities. Building something long-lived on a frozen framework is a decision, not a default.

CrewAI60.6k★

CrewAI builds a team of AI agents in Python. Each agent gets a role, a goal and tools, and a Crew passes tasks between them, in order or under a manager agent. Flows cover the opposite case: event-driven, step-by-step control when you don't want agents improvising. The framework is MIT and free. Setup is uv tool install crewai, then crewai create crew scaffolds a project where agents live in JSONC files. It's a standalone framework, not a LangChain wrapper. There's no server to run. Agents call OpenAI by default, and local models work through Ollama. The paid side is CrewAI AMP, a hosted platform with a visual editor, tracing and deployment. The free Basic plan gives you 50 workflow executions a month. Past that it's Enterprise, custom pricing only, which adds SSO, RBAC and deployment in your own VPC. No self-serve middle tier. Solo and small teams: free framework. Larger teams: Enterprise, or deploy it yourself. The catch: multi-agent setups multiply LLM calls and are hard to debug. Anonymous telemetry is on by default. And in March 2026 CERT/CC disclosed four flaws, including prompt injection to code execution via the Code Interpreter Tool, which CrewAI then removed.

LangGraph44.6k★

LangGraph builds AI agents as graphs: nodes do work, edges decide what happens next, and state persists between steps, so an agent can pause for human approval, recover from failures and pick up where it left off. It's from LangChain but works without it. The library is MIT and ungated. Run it anywhere Python or JavaScript runs, with a Postgres or SQLite checkpointer for persistence. LangGraph 1.0 shipped in October 2025 as a long-term-support release with a semver promise, so minor upgrades shouldn't break you; the churn now lives in beta features and the wider LangChain ecosystem. Two high-severity auth advisories in the SDK landed in August and September 2026, so stay current. The money is in LangSmith. Tracing is free for one seat with 5,000 base traces a month; Plus is $39 per seat a month with 10,000 base traces, then $5 per 1,000 more. LangChain's production Agent Server (task queues, cron, streaming endpoints) runs on LangSmith Deployment, metered by compute on Plus, and self-hosting that server requires Enterprise. Solo and small teams: free library plus your own server. Larger teams that want the managed runtime: budget for LangSmith. The catch: the free path means building your own serving layer. The moment you want LangChain's runtime on your own hardware, you're in an Enterprise sales conversation.

CopilotKit38.5k★

CopilotKit puts an AI agent inside your own app instead of bolting a chat bubble to the corner. The agent reads your app's state, calls your functions and renders real UI in the conversation, across React, Angular, Vue and React Native, plus Slack and Teams bots. Its makers also created AG-UI, the open protocol linking agents to frontends. The SDK is MIT licensed and free. The free setup is npm packages in your app plus a TypeScript runtime endpoint, with no extra service. Your real bill is LLM tokens, which grow with how much app state you hand the agent every turn. Telemetry is on by default; set COPILOTKIT_TELEMETRY_DISABLED=true to turn it off. The paid layer is CopilotKit Intelligence: threads that resume across devices, user memory, analytics and managed channels. Hosted is free for 1,000 interactions a month, then $49/month per organization with 10,000 included. Solo and small teams: free SDK. Medium teams wanting history without building storage: pay as you go. Large teams: Annual for SSO and offline installs. The catch: the free line is narrower than the MIT badge suggests. Only the TypeScript runtime works without Intelligence; the Python, Go, Ruby and .NET runtimes require it.

zeroclaw33.1k★

ZeroClaw is a self-hosted runtime for an autonomous AI assistant that lives on your hardware instead of someone's cloud. It connects to 20-plus model providers and 30-plus channels like Discord, Telegram, Matrix, and email, and acts through shell, browser, HTTP, and custom MCP tools. Written in Rust, dual licensed MIT or Apache 2.0, and free. You bring your own model keys, sign in with a Codex or Claude subscription, or run local models with Ollama. Running it is moderate work: you host the runtime, wire up the channels you want, and supply the models. It installs as a system service on Linux, macOS, or Windows, and now includes a web dashboard. It does not ship wide open. The default autonomy level is supervised, meaning medium-risk operations need approval and high-risk ones are blocked, with workspace boundaries, command policy, and OS-level sandboxes. A YOLO mode exists for trusted dev environments. Solo and small teams: free, and you pay only for model usage. Anyone who wants something vetted with support should stay with ChatGPT, Claude, or Copilot. The catch is still trust. An agent with shell access is only as safe as the policy you leave on and the model's judgment, so resist the urge to loosen the defaults. The newest release also adds ZeroRouter, a hosted model gateway in beta that needs a key and has no published pricing.

deepagents31.0k★

Deep Agents is LangChain's batteries-included agent harness. Where the base LangChain agent gives you a minimal loop, Deep Agents bundles the pieces you always end up building yourself: a filesystem, sub-agent delegation, context management, shell execution, persistent memory, human-approval steps, and reusable skills. It runs on any LLM that supports tool calling, MIT licensed and free. It installs as a Python package (uv add deepagents) and one call to its create_deep_agent helper gives you a working agent with your model, tools, and prompt. Under the hood it is built on LangGraph, so you inherit streaming, persistence, and checkpointing. Running it yourself costs nothing beyond your model's token bill, and a JavaScript/TypeScript port exists too. For a developer who wants a capable agent without wiring every subsystem by hand, this is a strong starting point at any team size. The money in the ecosystem is LangSmith for tracing and deployment: a free developer seat with 5K traces a month, then $39 per seat per month on Plus. A hosted Managed Deep Agents runtime is in private preview with no published price. The catch is the LangChain gravity. The package installs the LangSmith client plus Anthropic and Google integrations as required dependencies, and the production path points at LangSmith. If you like the batteries, it is a fast path. If you want a thin, transparent agent loop, this is more framework than you asked for.

mastra29.4k★

Mastra is a TypeScript framework for building AI agents into a web app: agents with tools and memory, workflows that can pause for a human to approve and then resume, RAG, evals and tracing. It routes to 40+ model providers through one interface and drops into a Next.js or Node app, or runs as its own server. The core is Apache 2.0, from a Y Combinator company. Self-hosting the framework just means deploying your app. The paid layer is Mastra Platform for tracing and hosted deployment: free for 100K events and 24 CPU hours a month, then Teams at $250/mo for 1M events, 250 CPU hours, six months of retention and SSO. Enterprise is custom. TypeScript teams who don't want to live in Python: this is the most complete option. Solo and small teams: the free framework plus the free platform tier. Compare it with langchain-ai/langchainjs for a bigger ecosystem, or Vercel's AI SDK for something lower-level. The catch is the ee folders. RBAC, SSO, fine-grained permissions and the visual agent builder sit under a separate Enterprise license: readable, but not for production without a paid key. Mastra has rewritten that license three times this year. Know which imports you're pulling in.

Haystack26.9k★

Haystack is an open-source Python framework for building LLM applications: retrieval-augmented generation, semantic search, and increasingly, autonomous agents. In plain terms, it is the plumbing that connects your documents and data to a language model and back out as an answer, with explicit control over each step. Apache 2.0 licensed, free via pip install haystack-ai, built by deepset. The design is modular pipelines: you chain swappable components (retrievers, rankers, generators, memory, tool-calling) into a workflow you can actually reason about. Version 2.x widened the scope from pure RAG to agent workflows, tool use, and multimodal apps, so the same framework that builds a document Q&A system now builds an agent that calls tools and keeps memory. Running it yourself is moderate work: the framework is free, but you supply the vector store, the LLM, and the infrastructure around them. Solo and small teams: pip install and go, then budget for the LLM API calls and a vector database, not for Haystack itself. Larger orgs that want managed deployment, observability, and governance can look at Haystack Enterprise, deepset's paid tier, available cloud or self-hosted. The framework gives you the control; Enterprise sells the operations layer on top. The catch is that Haystack's flexibility is also its learning curve. The pipeline model is powerful, but you have to design it, and you are on the hook for the costs it orchestrates: every LLM call and every vector query is your bill, not deepset's. Compare it against LlamaIndex and LangChain before committing, since all three cover overlapping ground with different opinions.

eliza19.8k★

elizaOS started as a framework for AI agents and now calls itself an agentic operating system. It's a runtime for agents that act across your chat apps, email, calendar, browser and wallet, plus a consumer Eliza app for web, desktop and mobile. It ships memory, document ingestion and connectors for Discord, Slack, Telegram, WhatsApp and X, and works with OpenAI, Anthropic, Gemini, Grok, OpenRouter or local models through Ollama. MIT licensed. Running it yourself is real work. The repo pins Node 24 and Bun, you bring model keys or run local models, and turning a demo into something reliable is a project, not an afternoon. Eliza Cloud is now the hosted route: sign-in, model routing and agent deployment, billed on credits. Its pricing sits behind a login. Solo builders who want control over their agent stack: a strong start. Teams that want a library rather than a whole runtime should look at mastra-ai/mastra or LangChain. Larger teams get the same code with no license ceiling. The catch is churn. The last stable npm release is from January, the repo's main branch is a v2 beta, and third-party plugins are no longer accepted, so older tutorials break. The official docs also carry tokenomics pages for an elizaOS crypto token.

langchainjs18.3k★

This is the framework that connects your code to LLMs. It handles the plumbing: talking to OpenAI/Anthropic/local models, managing conversation memory, chaining prompts together, and calling tools. What's free: Everything. MIT license, no paid tier in the library itself. LangSmith (their observability platform) has a free tier with limits. LangChain JS has become the default starting point for JS/TS AI applications. Active development, huge community. The abstractions for chains, agents, and retrieval are battle-tested. The catch: LangChain is famously over-abstracted. Simple things that take 5 lines with the OpenAI SDK directly take 20 lines through LangChain. The abstraction layers add latency and debugging complexity. If you're just calling an API and formatting the response, you don't need this. It earns its keep when you're building complex agent workflows with tool calling, retrieval-augmented generation (feeding your own documents to AI), or multi-step reasoning chains.

OpenHarness16.2k★

OpenHarness is agent infrastructure you pip install: the tool-calling loop, 43 built-in tools for files, shell, search, web, and MCP, plus skills, memory, permission modes, and multi-agent coordination. It also ships ohmo, a personal agent built on top of it that lives in Slack, Discord, Telegram, or Feishu and will fork a branch, write code, run tests, and open a PR on its own. MIT, Python 3.10 or newer, free. The ohmo part is the interesting trick. It runs on a Claude Code or Codex subscription you already pay for rather than a separate API key, so a chat-driven coding agent costs nothing extra. Setup is pip install openharness-ai, then oh setup to pick a provider and ohmo gateway start to put it in your chat app. It reads CLAUDE.md, loads Anthropic-style skills and plugins, and compacts its own context. Here is the problem. The last commit landed June 4, 2026, the last PyPI release was 0.1.9 on May 7, and there are dozens of open issues with nobody working them. This is a university research group's project that got popular fast, and popularity is not maintenance. For anything you depend on, langchain-ai/langgraph and crewAIInc/crewAI have real release cadences; for the coding agent job specifically, openclaw/openclaw is still shipping. The catch is that a stalled repo and a permission system make a bad pair. ohmo runs shell commands and opens PRs on your behalf, which is exactly the code you want getting security fixes. Fine for a prototype on a throwaway repo. Not something to point at code you care about until commits resume.

agent-framework14.6k★

Microsoft Agent Framework is what AutoGen and Semantic Kernel turned into. Same teams, one SDK, and it reached 1.0 in April 2026 with a long-term support commitment behind it. You get agents, graph-based workflows for sequential, concurrent, and handoff patterns, and an opinionated harness agent that handles planning, todo tracking, and context compaction on long jobs. MIT licensed, all of it. There is no server to run. Install the Python or .NET package and your only bill is the model provider. It talks to Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, and Ollama, so choosing it does not lock you to Azure. OpenTelemetry is wired in for tracing and the local DevUI gives you step-through debugging of a running workflow. Python and .NET are the mature targets; Go exists but is public preview and missing declarative agents and RAG. If you are a .NET shop, treat this as the default and stop shopping. Python teams already productive on langchain-ai/langgraph do not have a strong reason to migrate. Solo builders will get moving faster on crewAIInc/crewAI. The catch: this is a migration, not an upgrade. microsoft/autogen is now in maintenance and its future work happens here, so getting current means rewriting against a migration guide. Pick your lane before you end up running three agent stacks in production.

skills13.8k★

MiniMax Skills is a framework for creating task-specific agent capabilities. Instead of one general-purpose agent that's mediocre at everything, you build focused skills that each do one thing reliably. Built by MiniMax (a major Chinese AI company), it's written in C# and designed for their agent ecosystem. You define skills as modular units that agents can discover, load, and execute. A plugin system for AI agents. MIT licensed. The catch: this is deeply tied to MiniMax's ecosystem. If you're not using their models or agent infrastructure, the value drops significantly. The C# implementation is unusual in a Python/TypeScript-dominated AI landscape; your team needs C# experience. And 'skills framework by a model provider' means the framework is optimized for their models, not necessarily yours.

OpenSpace7.8k★

OpenSpace is a librarian for the skill files your coding agent piles up. Version 2, released in July 2026, dropped the original self-evolving-agent pitch for something concrete: find the right skill, track whether it worked, share the ones that did, retire the ones that did not. All MIT licensed, including the community library at open-space.cloud. Running it means Python 3.12 or newer, a pip install, and wiring an MCP server into Claude Code, Codex, OpenClaw, or nanobot. Skills and execution stay local, and the cloud is optional. The dashboard is a second install needing Node 20. You bring your own model key, so the running cost is tokens. Solo developers with a dozen skill files do not need this, and a curated pack like slavingia/skills is a smaller commitment. It pays off once a team shares hundreds of skills and nobody can say which still work. The catch: this comes out of an academic lab, and its Terminal-Bench 2.1 result, 65.2% cold to 78.7% warm, was run on its own harness. Self-evolving skills mean an agent rewriting its own instructions, and the restrictive policy that limits it to repairs is not the default. The shared library is still thin.

OpenDots6.4k★

OpenDots is CopilotKit's open answer to OpenAI's Dots, launched the same day: a web app where you spin up always-on AI coworkers, each with a role, permissions, its own sandboxed computer, a Slack presence and voice calls. The app code is MIT. The part that makes chat work is not. Conversations run through CopilotKit Intelligence, a proprietary backend. You either use CopilotKit's hosted service, run a local evaluation in Docker Desktop on macOS that wants 12 GiB of RAM and expires every 30 days, or buy a self-hosted license. Bring your own OpenAI-compatible model key; voice calls only work through OpenAI's Realtime API. Dot computers need OpenBot's container services (CopilotKit/OpenBot). The free Developer tier covers one developer with 3-day thread retention. Pro is $39 a month, Team is $100 per seat a month for up to 5 seats, and Team is the cheapest plan that includes self-hosting. Solo tinkerers can try it free. Teams eyeing production should price Team or Enterprise before forking anything. n8n (n8n-io/n8n) and Dify (langgenius/dify) self-host end to end if the lock-in bothers you. The catch: it's an alpha template with no releases, single-owner by design (no shared editing yet), and telemetry is on by default. Open source here means the front of the house.

nexent6.1k★

Nexent builds AI agents from a plain-language description. Say what the agent should do and it generates one, wired to MCP tools, a searchable knowledge base of your documents, memory and other agents. Huawei is behind it (the code's copyright is Huawei Technologies), it's MIT licensed, and it competes with Dify, Coze and Flowise. Self-hosting is free. This is not a weekend toy. The Docker minimum is 4 cores, 8 GiB of RAM and 40 GiB of disk, and the stack brings Elasticsearch, PostgreSQL, Redis, MinIO and a slimmed-down Supabase for auth. bash deploy.sh docker walks you through it; Helm covers Kubernetes. You bring your own OpenAI-compatible models, so the LLM bill is yours. There is no paid tier or hosted version; the website the README links to doesn't resolve. Solo: free, with a spare 16 GB box. Small teams: free, with multi-tenancy and role-based access built in. Larger teams: free, but you are the support desk. The catch is security. An October 14 CVE lets any signed-in user read other tenants' knowledge-base files through version 2.7.0, and the access check on main still allows it. Two unauthenticated file-deletion bugs hit the 1.x line in May. Keep it single-tenant and off the public internet.

eve5.8k★

Eve is Vercel's framework for building durable AI agents where the agent's definition lives as plain files, not buried in code. Its instructions, tools, skills, message channels, and scheduled jobs sit in a conventional folder layout you can read, diff, and reason about. Apache-2.0, free, and currently in public beta. The filesystem-as-source-of-truth idea is the interesting part: an agent's behavior is inspectable and version-controlled instead of tangled in application logic. It is a TypeScript/Node framework you run yourself, so the ops are moderate and familiar. Being a Vercel project, it is oriented toward their deployment and model ecosystem, and being public beta, the APIs can still move under you. This is for TypeScript developers who want maintainable, inspectable agents and like the idea of the agent's whole definition being files on disk. Solo and small teams: free to build and run. Larger teams: free framework, but factor in beta churn and the Vercel-shaped defaults. If you want a managed agent platform with a stable API and a support contract, LangGraph Platform or OpenAI's Assistants API are the paid alternatives. The catch is beta. The design is clean and the file-based approach is a readable way to keep agents legible, but public beta means expect breaking changes and thin edges. Build with it if you are comfortable tracking a moving target; wait if you need stability today.

autoagent4.6k★

AutoAgent is a meta-agent framework: you give it a task, and it builds and iterates on an AI agent harness autonomously. It modifies the system prompt, tools, and orchestration, runs a benchmark, checks the score, keeps improvements, discards regressions, and repeats. Automated prompt engineering on steroids. The human steers via a program.md directive in plain markdown. The meta-agent edits the actual agent.py code, runs it in Docker isolation, and hill-climbs on a 0-1 score. You write the goal, it does the iteration loop. Built by thirdlayer.inc, who are building a commercial product around self-configuring agents. For AI engineers building complex agent systems who want to automate the tuning loop: this is worth watching. You need existing benchmark tasks in Harbor format and a working harness to start from. It does not build your first version, only improves it. The catch: the README claims MIT but there is no LICENSE file in the repo. That is a red flag for production use. The commercial angle (thirdlayer.inc signup form in the README) suggests the open source version may not stay fully open.

commerce-agents3.4k★

commerce-agents is Anthropic's reference blueprint for building two things on Claude: a shopping agent you embed for customers, and a merchant agent your staff use to run the back office. It is not a product you install, it is example code (real runnable agents across retail, travel, telecom, and entertainment) that shows how to wire the pieces together. Apache-2.0. The value is the pattern, not the demo. Each agent is defined once (prompt, skills, tool contracts, approval gates) and runs on the Messages API, the Agent SDK, and Managed Agents. There is a Claude Code plugin that scaffolds a new agent against your own systems. Nothing here places a real order or charges a card; every write is staged until a person approves it. If you are building commerce agents on Claude, start here instead of from a blank file. It shows the safety scaffolding (the fencing, the staged writes, the approval surface) that you would otherwise learn the hard way. The catch: the code is free but Claude is not. You bring an API key, and cost scales with usage. This is a starting point wired to Anthropic's own stack, not a vendor-neutral framework.

Shannon2.3k★

Shannon is a multi-agent orchestration framework built in Go with a Rust agent core and Python LLM layer. It manages complex AI workflows: task decomposition, multi-agent coordination, token budgets with automatic model fallback, and time-travel debugging that lets you replay any execution step. Supports 10+ LLM providers including Anthropic, OpenAI, and Ollama. The architecture is serious infrastructure: Temporal for durable workflows, OPA for policy enforcement, Prometheus metrics, OpenTelemetry tracing, and human-in-the-loop approval gates. Multiple execution strategies (DAG, ReAct, Research, Swarm, Browser Use) cover different agent patterns. Docker Compose spins up Go gateway, Rust core, Python LLM service, Temporal, PostgreSQL, and Redis. Teams building production agent systems who need observability, cost control, and multi-tenant isolation will find the feature set compelling. The token budget enforcement with automatic fallback to cheaper models is a useful idea for controlling LLM spend. The catch: very early stage with minimal commit history. The feature list reads like aspirational docs more than battle-tested reality. Three languages (Go, Rust, Python) means three ecosystems to debug. Temporal alone is a significant operational dependency. Watch this project, but don't bet production on it today.

unreal-agent2.2k★

Unreal Agent is a Go library and command-line runner for building coding agents, the plumbing behind tools like codex exec or claude -p. Its twist is async tool calls: a slow command runs in the background while the model keeps working, instead of burning turns waiting. Sessions are saved, append-only and forkable. MIT, from Unreal Labs. It plugs into OpenAI, OpenRouter, Fireworks and Ollama, or reuses a Codex ChatGPT login. The tool set is deliberately small: a shell, image viewing and skills. The company's own benchmarks claim Codex-level scores at up to 40% lower cost. Those numbers are self-reported. Teams building their own agent harness in Go, or chasing cost per task: worth reading and forking. People who just want a coding agent should use Codex or Claude Code directly. The catch: the official Docker image is published as unrea1labs, with the digit 1 where the l should be, and someone else holds the correctly spelled name on Docker Hub. Install from the Go module or GitHub releases instead, and note the repo hasn't moved since its first week.

adk-java1.8k★

ADK (Agent Development Kit) for Java is Google's official toolkit for building, evaluating, and deploying AI agents. Define tools, orchestrate multi-step reasoning, handle conversation state, and evaluate agent performance all within your Java codebase. Apache 2.0. This is early but backed by Google. It integrates with Google's AI models (Gemini) and supports the broader agent ecosystem. Fully free and open source. No paid features in the toolkit. You pay for the AI models you call through it: Gemini API pricing, Vertex AI costs, or whatever LLM you connect. The catch: Java in the AI agent space is unusual; most agent frameworks are Python or TypeScript. The ecosystem of examples, tutorials, and community plugins is small compared to LangChain or CrewAI. If your team is already in the Java ecosystem (Spring Boot, enterprise backends), this makes sense. If you're starting fresh, Python frameworks have 10x the community support. And it's early; the API is still evolving.