Cadenya
Paid
Developers building agentic workflows
Most multi-agent frameworks give you a coordination layer without a memory layer — agents finish tasks and forget everything, so the next run starts cold. GOAT2 is built around the opposite assumption: memory is not optional infrastructure, it is the core architecture.
GOAT2 runs a Telegram-facing multi-agent system on top of async DAG execution, with a three-tier memory stack — Redis for fast session state, ChromaDB for vector retrieval, and Letta for longer-horizon behavioral learning. The DAG runner means agents can execute in parallel where dependencies allow, rather than waiting in a serial queue. The modular layout — separate directories for agents, orchestrator, memory, plugins, registry, and tools — means you can swap a backend without rewriting everything else. The wall appears when you need a non-Telegram interface: the docs describe Telegram as the primary entry point, and rerouting to another frontend requires you to rebuild the interface layer yourself. Teams that need a REST API or web UI will be adding code before they ship anything.
Bottom line: Pick GOAT2 when you are building a Telegram-native agent system and need memory that persists across sessions; skip it when your interface is a web app or REST endpoint, because the Telegram-first architecture means that surface is yours to build.
Find your fit
More options in Agent Frameworks. Compare pricing, platforms, and features side by side.
Paid
Developers building agentic workflows
Free · Open source
Long-term continuity in multi-session coding projects
GOAT2 is an open-source Python project that wires together a Telegram bot interface, a DAG-based task runner, and a three-tier memory system to support multi-agent workflows where agents need to remember what happened before. The core loop is: a Telegram message arrives, the orchestrator parses intent, tasks are distributed across agents in a dependency graph, results are stored to the appropriate memory tier, and responses return through Telegram. The registry and config directories act as a central control plane — agent definitions, model backends, and plugin configurations are declared there rather than scattered across agent files.
The memory architecture is the sharpest differentiator. Most open-source agent frameworks offer one memory layer, usually a vector store. GOAT2 layers three: Redis handles fast, ephemeral session context so an in-progress conversation does not have to re-fetch state; ChromaDB handles semantic retrieval across prior sessions; and Letta handles behavioral learning — the docs describe this as the system adjusting agent behavior based on accumulated interaction history. That combination means an agent can recall what a specific user asked two weeks ago and also surface documents semantically similar to the current query, without those two lookups interfering with each other.
This architecture fits teams building personal or team-facing Telegram assistants that need continuity across sessions — support agents, research assistants, internal tools. It fits less well when you need a web or mobile frontend, when you need to expose an API for external systems to call, or when your team lacks the Python depth to configure Redis, ChromaDB, and Letta as separate services. The GitHub repository shows zero open issues and two stars at the time of curation — this is a solo or small-team project without a public community to troubleshoot against, which matters when you hit an undocumented edge case.
The repository structure is explicit: agents, orchestrator, memory, plugins, registry, tools, telegram_interface, and benchmark directories each hold their own logic, connected by a central config registry. The project ships with a requirements.txt for production dependencies and a requirements-dev.txt for testing, plus a separate SETUP.md — which the vendor states covers the configuration steps for getting all three memory backends running together.
Sign in to rate this tool or suggest an edit.