Open-source agentic framework

Reasoning in concert.

A framework for composing multi-agent systems — a DAG executor, any channel, browser and code autonomy, durable memory, and observability. Score the logic once, and let your agents perform in time.

Star on GitHub Read the docs →

        MIT licensed/Python & TypeScript/v0.6
      

The ensemble

          DAG
          Channels
          Browser
          Sandbox
          Memory
          A2A
          Observe
        

Capabilities

Every part you need to build a full agent.

Six movements form the core. Everything else composes cleanly on top.

01

Multi-agent DAG executor

Compose agents as a directed graph and run it deterministically — built from scratch, no black boxes.

02

Any channel, in a day

Wire agents to WhatsApp, Slack, Discord, or voice without rewriting a line of logic.

03

Browser & computer use

Grant real autonomy: navigate the live web and operate a machine on the user's behalf.

04

Sandboxed execution

Run model-generated code safely in isolated containers with strict resource limits.

05

Memory & recall

Remember context across sessions, learn user preferences, and replay proven workflows.

06

Platform API (A2A)

Expose any agent as an endpoint other agents can call — a true agent-to-agent network.

Also scored in Observability & cost controls GAIA benchmarking Dynamic UIs — A2UI / AG-UI Event-stream autonomy Safe-autonomy constraints System-2 coding agent

Benchmarks / GAIA validation · illustrative

72%

GAIA Level 1

54%

GAIA Level 2

38%

GAIA Level 3

$0.11

Avg cost / task

Reproducible harness ships in the repo — run the suite yourself, trace every step, and account for every token spent.

Compose

A graph you can read like a score.

ensemble.py

from reasonata import Graph, Agent

g = Graph("support-desk")

planner = g.add(Agent("planner", model="claude"))
browser = g.add(Agent("browser", use=[web]))
coder   = g.add(Agent("coder",   use=[sandbox]))
memory  = g.add(Agent("memory",  recall=True))

# fan out, then remember
g.edge(planner >> [browser, coder] >> memory)

g.serve(channel="slack")   # live in a day

Execution graph

The planner conducts; tools perform in parallel; memory keeps the score for next time.

Start on GitHub Read the quickstart →