Agent Graph
A Multi-Agent System built on Context Engineering principles, enabling developers to visually build, test, and deploy complex multi-agent applications quickly.
- Source repo
- keta1930/agent-graph
- Stars
- ★ 239
- Last updated
- 4d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 53/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platform
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- 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
- Source review
- 53/100 · Major gaps 1 safety controls not found
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).
- 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
- Product teams that need agents to remember user preferences and knowledge bases across sessions via short-term and long-term memory
- Developers with OpenAI-compatible LLM APIs who want to connect databases, APIs, and file systems through MCP servers as a unified tool layer
- Ops or data scenarios requiring scheduled or periodic workflow execution, using Task scheduling (cron expressions, concurrent instances, execution history)
- Organizations needing team collaboration over agents and prompt templates, with invitation-code registration, role permissions (Super Admin, Admin, Regular User), and a prompt center
- 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.envdocker/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.
- Clone the project:
git clone https://github.com/keta1930/agent-graph.git
cd agent-graph- 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 -dDefault service addresses: MongoDB Express (database management) http://localhost:20041, MinIO Console (file storage) http://localhost:20043.
- Deploy the backend (
uv recommended):
uv sync
uv run --env-file .env fastapi runOr with pip:
pip install -r requirements.txt
dotenv -f .env run -- fastapi runRun 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?
- 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.
- In the Workspace, create and configure agents: set system prompts, tools, and model parameters; configure LLM/VLM API keys in model management.
- 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.
- 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.
- 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?
- 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
- 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?
Why each dimension lost points
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).
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).
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).
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).
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).
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.
- 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.
FAQ
What services and resources does deployment require?
Is Agent Graph itself paid?
How do I connect external tools and data sources?
Does it support scheduled automatic workflow execution?
Does it support team collaboration?
Is Agent Graph open source?
Is Agent Graph safe to use?
Is Agent Graph still maintained?
Who makes Agent Graph?
Thanks — we use this to improve the page.