AgentLoop Documentation
AgentLoop is a custom agent engine — a platform for building, running, and continuously improving autonomous multi-agent systems. You compose agents on a visual canvas, run them with deterministic control and full observability, and improve how they decide with a learned neurosymbolic loop that blends neural networks, symbolic logic, and learned utilities.
AgentLoop is currently in an early access beta. Features and APIs may change. Join our Discord to follow along and report issues.
Quick Navigation
Install AgentLoop and run your first project.
Getting StartedTour the workspace, views, and chat surface.
Desktop AppSee how the engine, daemon, and agents fit together.
ArchitectureThe behavior-tree agents and how to customize them.
AgentsWhat is AgentLoop?
If you’ve used a visual automation tool like n8n or an agent framework like LangGraph / LangSmith, the shape of AgentLoop will feel familiar: a canvas for wiring up agents and workflows, with deep observability into every run. What sets it apart is how its agents decide.
Every agent is driven by a behavior tree that combines three kinds of decision-making in one loop:
- Neural — neural networks for perception and judgment: LLMs for language, plus vision and other models for real-time sensing and control
- Symbolic — deterministic logic rules that verify decisions and catch hallucinations
- Learned — utility weights tuned from experience, so agents get better at choosing what to do next
This neurosymbolic loop produces agents that are flexible and reliable — auditable tick by tick, grounded by logic, and able to improve with training. It’s the core differentiator, and it’s why AgentLoop can drive real-time, autonomous systems, not just a chat assistant.
A General-Purpose Engine
AgentLoop isn’t tied to a single domain. The same engine runs agents anywhere autonomous systems must perceive, decide, and act under real constraints:
- Software development — the flagship application, fully built out (covered throughout these docs)
- Robotics — tick-by-tick control loops over sensors and actuators
- Simulation & game AI — agents that play, test, and adapt inside simulated worlds
- Autonomous vehicles & control systems — decision logic that has to stay verifiable, not just plausible
These docs currently focus on AgentLoop’s software-development application — the most complete one today. The neurosymbolic engine underneath it is domain-agnostic, and support for other domains is expanding.
Software Development, Out of the Box
AgentLoop’s first complete application is an autonomous software-development team. You describe what you want in natural language; AgentLoop breaks the work into tasks, schedules them on a dependency graph, assigns them to specialized agents working in isolated git worktrees, and tracks each one through implementation and review — all visible and controllable from a desktop GUI.
Specialized agents work together:
- Product Manager — Breaks down requests into AGILE tasks with dependencies
- Engineer — Implements code changes with proper git workflows
- QA Tester — Validates changes, runs tests, and bounces work back when needed
- Release — Opens pull requests for completed work
- Merge Resolver — Coordinates and merges parallel branches
- Plus specialized variants for Electron apps, web E2E testing, and more
Key Features
| Feature | Description |
|---|---|
| Neurosymbolic Agents | Behavior-tree agents that fuse neural networks, symbolic logic, and learned utilities in one decision loop |
| Learned Decision-Making | Utility-driven nodes whose weights can be tuned from experience, so agents improve over time |
| Visual Workflow Editor | An n8n-style node-graph canvas for composing cross-agent automations with cron, webhook, and event triggers |
| Full Observability | Inspect every agent’s behavior tree tick by tick, and replay recorded runs |
| Deterministic Control | Auditable, repeatable agent workflows — not an opaque prompt chain |
| Domain-Agnostic Engine | The same engine targets software, robotics, simulation, and control systems |
| Desktop GUI | A full desktop app for building, running, debugging, and watching agents |
| Chat-First Control | Drive everything in natural language, with tool calls streaming live as agents work |
| DAG-Based Orchestration | Define dependencies; the orchestrator picks the optimal execution order and maximizes parallelism |
| Git Worktrees & Sandboxing | True branch isolation, plus optional Podman container isolation, so parallel agents never collide |
| Extensible | Custom agent templates, behavior trees, composable skills, and MCP tool integration |
Documentation Sections
Getting Started
- Installation — Install the desktop app and sign in
- Desktop App — Tour of the workspace and views
Workspace Views
- Chat — The conversational home surface
- Tasks — The kanban task board
- Workflows — Visual cross-agent automations
- Agents — The agent workbench and agent types
- Specs — The project spec library
- Skills — Composable per-agent capabilities
- Alerts — Notifications and workflow alerts
Core Concepts
- Architecture — How the app, daemon, and agents fit together
- Orchestrator — Task scheduling and DAG management
- Neurosymbolic Systems — The concept and research behind the engine
Building Agents
- Custom Agents — Create and develop your own agents
- Behavior Trees — How agents decide, and every node type
- Behavior Tree JSON — The authorable behavior-tree file format
- Authoring Behavior Trees — Build them with chat and LLMs
- Debugging Behavior Trees — Time-travel, fixtures, and forking
- The Neurosymbolic Loop — Neural, symbolic, and learned decision-making
- Logic Programming — Write rules and wire up a logic node
Runtime & Isolation
- Git Worktrees — Parallel development with isolated branches
- Container Sandboxing — Podman-based agent isolation
- Background Daemon — How the daemon stays running
Integrations & Configuration
- Integrations — Jira, GitHub, and MCP servers
- Configuration — Configuration reference
Need help? Join our Discord community or visit agentloop.run .