Agent Graph

A Multi-Agent System built on Context Engineering principles, enabling developers to visually build, test, and deploy complex multi-agent applications quickly.

Stars
★ 239
Last updated
4d ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
Self-hosted serviceWeb appFramework
Works with
Universal · cross-platform
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Docker 20.10+ with Docker ComposePython 3.11+uv (recommended)4GB RAM (8GB recommended)10GB storageShell / CLINetwork accessLocal filesystemMCP Server
Typical use
Teams that need to orchestrate multiple agents into predictable multi-stage flows (linear, parallel, conditional) using a visual editor instead of hand-written orchestration code
Not a fit if
  • Teams wanting a hosted SaaS with no self-managed Docker, MongoDB and MinIO services
  • Developers seeking a lightweight CLI that runs without deploying multiple services
  • Windows users unable to use WSL2
Maintenance
Commits in the last 30 dayslast commit 2026-11-17

What does this agent do, and when should you use it?

Agent Graph (GitHub repository keta1930/agent-graph) is a self-hosted Multi-Agent System built on Context Engineering principles, released under the Apache-2.0 license. It integrates sub-agents, long-term memory, the MCP protocol, and agent-based workflows. Core components include Agent, Graph (workflow), model management (OpenAI-compatible LLM and VLM support), memory, a prompt center, and projects. The system ships with a frontend drag-and-drop visual graph editor supporting linear, parallel, conditional, and nested graph types, plus subgraph nesting, smart routing (Handoffs), and scheduled task execution. Deployment uses Docker Compose to start services such as MongoDB and MinIO, with a FastAPI backend run via uv or pip, accessible by default at http://localhost:20050.

Agent Graph lets developers create and manage agents, design workflows, configure models and API keys, manage MCP server connections, maintain prompt templates, and inspect long-term memory through a visual workspace frontend. An Agent is an AI entity that understands goals, uses tools, iterates and optimizes, maintains context and long-term memory, and solves open-ended tasks through autonomous action execution; a Graph orchestrates multiple agents into structured workflows with execution flow defined by nodes and edges. The system connects external tools and data sources (databases, APIs, file systems, cloud services) via the MCP protocol, and provides built-in tools (Agent Creator, Graph Designer, MCP Builder, Prompt Generator, Task Manager). Subgraph nesting enables modular, hierarchical workflows; Handoffs let nodes dynamically pick the next execution node; and the Task feature schedules automatic graph execution with cron expressions, concurrent instances, and execution history. Once deployed, it exposes a web chat interface, API documentation (/docs), and a health check (/health).

  1. Teams that need to orchestrate multiple agents into predictable multi-stage flows (linear, parallel, conditional) using a visual editor instead of hand-written orchestration code
  2. Product teams that need agents to remember user preferences and knowledge bases across sessions via short-term and long-term memory
  3. Developers with OpenAI-compatible LLM APIs who want to connect databases, APIs, and file systems through MCP servers as a unified tool layer
  4. Ops or data scenarios requiring scheduled or periodic workflow execution, using Task scheduling (cron expressions, concurrent instances, execution history)
  5. Organizations needing team collaboration over agents and prompt templates, with invitation-code registration, role permissions (Super Admin, Admin, Regular User), and a prompt center
  6. Builders of applications needing visual understanding, adding multimodal support to agents via VLM models

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • pip install -r requirements.txt
Ports
20041 · 20043
Environment variables
PUBLIC_API_BASE_URL
Config files
.env.example .env docker/docker-compose.yml
Runtime
Python 3.11+
Install notes cover
Windows · macOS · Linux · WSL · Docker

How do you install or deploy this agent?

Requirements: Linux, macOS, or Windows (WSL2 required), Docker 20.10+, Python 3.11+, minimum 4GB RAM (8GB recommended), at least 10GB free storage.

  1. Clone the project:
git clone https://github.com/keta1930/agent-graph.git
cd agent-graph
  1. Configure and start Docker services (MongoDB, MinIO, etc.):
cp .env.example .env
# Set all blank credentials and secrets before startup
python agent_graph/scripts/generate_jwt_secret.py
docker compose --env-file .env -f docker/docker-compose.yml up -d

Default service addresses: MongoDB Express (database management) http://localhost:20041, MinIO Console (file storage) http://localhost:20043.

  1. Deploy the backend (uv recommended):
uv sync
uv run --env-file .env fastapi run

Or with pip:

pip install -r requirements.txt
dotenv -f .env run -- fastapi run

Run in the background:

nohup uv run --env-file .env fastapi run > app.log 2>&1 &

Optional: to modify frontend code, run npm install and npm run dev in the frontend directory (the repository already includes pre-built frontend files).

How do you use this agent?

  1. Open the address configured by PUBLIC_API_BASE_URL (default http://localhost:20050), log in as admin with the username and password set in .env, or register as a new user with an invitation code.
  1. In the Workspace, create and configure agents: set system prompts, tools, and model parameters; configure LLM/VLM API keys in model management.
  1. Design graphs in the workflow management section with the visual drag-and-drop editor, orchestrating linear, parallel, conditional, or nested flows; reuse entire graphs as subgraph nodes, or configure Handoffs so nodes dynamically choose the next execution node.
  1. Add MCP server connections in MCP management to reach external tools and data sources; manage reusable prompt templates in the Prompt Center; review agent long-term memory and knowledge bases in memory management.
  1. Chat with agents from the chat page, or configure workflows as scheduled tasks (cron expressions) that run automatically.

Other endpoints: API docs at http://localhost:20050/docs, health check at http://localhost:20050/health. Detailed installation docs are in docs/first-steps/install.md; official documentation at https://keta1930.github.io/agent-graph/.

What are this agent's strengths and limitations?

Pros
  • Visual drag-and-drop graph editor supports linear, parallel, conditional, and nested graph types, enabling WYSIWYG multi-agent workflow orchestration without hand-written orchestration code
  • Native MCP protocol integration connects external tools and data sources once and uses them everywhere, backed by built-in system tools such as Agent Creator, Graph Designer, and MCP Builder
  • Built-in short-term and long-term memory system persists user preferences and knowledge bases across sessions, paired with a prompt center for centralized template management and cross-project references
  • Subgraph nesting and Handoffs smart routing enable modular, hierarchical workflows, while Task scheduling supports cron expressions and concurrent instances
Limitations
  • Non-trivial deployment: Docker Compose must start multiple services including MongoDB and MinIO, and you must configure .env credentials and a JWT secret yourself; Windows requires WSL2
  • Docs only state support for OpenAI-compatible LLM/VLM models without detailing provider adapters, so you must verify your own models' compatibility and bear API usage costs
  • Some capabilities are still roadmap items: team resource sharing and Agent Skills are listed as coming soon, while external Agent API and user analytics remain in planning
  • The self-hosted frontend/backend architecture means you own the operational, upgrade, and security burden (credentials, invitation codes, role permissions)

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Agent Graph This agent 53 · Major gaps Self-hosted serviceFree + model costs ★ 239 4d ago Python —
PowerContext 82 · Good CLIFree ★ 1.8k 1d ago Python Codex · Claude Code
Memoh 50 · Major gaps — ★ 2.8k 2d ago Go Codex · Claude Code
Puppyone 47 · Major gaps Self-hosted serviceFreemium ★ 1.3k 5mo ago TypeScript ChatGPT · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
53/ 100 5-point scale 2.7 / 5
Trust 11/29
Reliability 8/14
Adaptability 9/18
Convention 12/18
Effectiveness 9/13
Verifiability 4/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

Evidence shows a JWT secret generator script, mandatory blank .env fields, and a production security checklist (firewall/HTTPS/unique credentials), so sensitive credential handling has basic guidance (2). But deductions are concrete: Agents can connect to databases/APIs/file systems via MCP, create files, and run scheduled Graphs, with no evidence of tool-level permission controls or pre-execution user confirmation (least_privilege=1, user_confirmation=0, external_effects=1); data-flow transparency (data persisted to MongoDB/MinIO, sent to LLM vendors) is described only at feature level (data_flow_transparency=1); many dependencies are unpinned (langchain, openai, aiohttp) with no audit/lockfile (dependency_security=1); no rollback/backup scheme (rollback=1). Named author, citation format, and full Apache-2.0 text support attribution (2).

Reliability8 / 14 · 2.9/5

Documentation is internally consistent: commands, ports and flows in README, AGENTS.md and install.md agree (self_consistency=2); a /health endpoint, a unified 500 handler, and bilingual troubleshooting tables support failure messaging (failure_messages=2). Deduction: dependency availability is weak — langchain, openai, aiohttp etc. are entirely unpinned, and requirements.txt duplicates pyproject.toml, creating drift risk (dependency_availability=1).

Adaptability9 / 18 · 2.5/5

Developer/team audience is clear and deployment environment (Linux/macOS/WSL2, Docker version, memory) is specific (audience_and_scenarios=2, environment_fit=2). Deductions: capability boundaries appear only as marketing language ('autonomous action execution') without limits on failure, overreach, or cost (capability_boundaries=1); no evidence on precision of Handoffs/Task triggers or misfire safeguards (trigger_precision=1).

Convention12 / 18 · 3.3/5

Information architecture is the project's strongest area: bilingual doc tree, TOC, strict MkDocs CI, thorough install doc with a verification table (information_architecture=3, install_notes=3); complete Apache-2.0 text consistent with pyproject (license=3). Deductions: no CHANGELOG, and version 3.0.0 contradicts SECURITY.md's '>1.2.0 / <1.1.0' ranges (versioning_changelog=1); known limitations essentially unwritten, roadmap used as a substitute (known_limitations=1); maintenance rests on one individual, and SECURITY.md lists [email protected] immediately followed by the placeholder [email protected] — weak maintenance path (maintenance_responsibility=1); naming and examples are consistent but no FAQ (naming_stability=2, examples_and_faq=2).

Effectiveness9 / 13 · 3.5/5

Pre-seeded welcome conversation, demo workflow, Creator Agents, and troubleshooting tables make outputs usable for new users (output_usability=2); visual orchestration + memory + MCP + scheduling offers real differentiation over raw LLM APIs (marginal_value=2); but minimum 4GB/10GB with MongoDB+MinIO+backend+frontend is heavy for a single user and self-hosting cost is non-trivial (cost_benefit=2).

Verifiability4 / 8 · 2.5/5

Commands and ports cross-corroborate across README/AGENTS.md/install.md/quickstart (cross_source_corroboration=2); docs link to specific sub-pages aiding traceability (claim_traceability=2). Deduction: promotional claims such as 'rapidly build complex multi-agent applications' and 'Context Engineering best practices' carry no benchmark or test evidence — facts and inference are not separated (fact_inference_separation=1); the packet contains only tests/conftest.py, so coverage claims cannot be verified.

Risks and how to mitigate them
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Agents can access external databases, APIs, and file systems via MCP and run scheduled Graphs; no tool-level permission controls or pre-execution user confirmation are visible in the packet — strictly restrict MCP server scope and credentials after deployment.
  • SECURITY.md leaves the placeholder [email protected] next to the reporting address, and its supported-version ranges contradict pyproject's 3.0.0; the security contact path is unreliable and should be re-verified against the repository.
  • Core dependencies (langchain, openai, aiohttp) are unpinned and requirements.txt duplicates pyproject.toml, risking build drift; lock and audit dependencies yourself.
  • Docs ship weak example credentials (strongpassword123, minioadmin123); replace all with unique strong values as instructed, and network-isolate admin UIs such as Mongo Express and the MinIO console.
  • Claims of 'Context Engineering best practices' and rapid complex-app building have no benchmark or test evidence; only test fixtures appear in the packet, so coverage and quality cannot be statically verified.
Evidence confidence: Low Reviewed Nov 21, 2026 Reviewed revision 4b2aab227e18
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/agent-graph.svg)](https://followagents.com/en/agents/agent-graph)
<a href="https://followagents.com/en/agents/agent-graph"><img src="https://followagents.com/badge/agent-graph.svg" alt="FARS review"></a>

FAQ

What services and resources does deployment require?
Docker 20.10+ with Docker Compose to start services (including MongoDB Express and MinIO), Python 3.11+, minimum 4GB RAM (8GB recommended), at least 10GB storage; Windows requires WSL2. The FastAPI backend runs via uv or pip on default port 20050.
Is Agent Graph itself paid?
The project is open source under Apache-2.0 and free to use; however, model management requires API keys for OpenAI-compatible models, and actual LLM/VLM usage costs are borne by the user.
How do I connect external tools and data sources?
Via the MCP protocol: add MCP server connections in the workspace's MCP management page to reach databases, APIs, file systems, and cloud services — connect once and use everywhere.
Does it support scheduled automatic workflow execution?
Yes. The Task (scheduling) feature runs graphs automatically on a schedule or periodically, supporting cron expressions, concurrent instances, and execution history tracking.
Does it support team collaboration?
Yes. Admins can create invitation codes, manage team members, and assign role permissions (Super Admin, Admin, Regular User); team resource sharing (sharing agents, workflows, and prompts within teams) is currently listed as coming soon.
Is Agent Graph open source?
Yes. The source code is on GitHub (keta1930/agent-graph) under the Apache-2.0 licence.
Is Agent Graph safe to use?
FollowAgents' FARS review (Nov 21, 2026) scored Agent Graph 11/29 on trust and safety. The review did not find these safety controls in the source: confirmation before acting. Before giving it real accounts or data: Turn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
Is Agent Graph still maintained?
Yes. The latest commit on GitHub is from 2026-11-17, within the last 30 days.
Who makes Agent Graph?
Agent Graph is published on GitHub by the account keta1930. FollowAgents has not verified which person or company is behind that account.
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts