Binex

Binex is a free, open-source program for running a chain of AI steps on your own computer, such as: draft an order, let a person approve it, then process the payment. It records what every step received, produced and cost, so when the end result is wrong, a developer can see which step caused it. One developer started it in March 2026.

What does Binex do?

Its README of March 2026 (version 0.6.5) calls it an "open-source visual orchestrator for AI agent workflows" that runs "100% locally". You describe a workflow as a directed acyclic graph (DAG): steps, called nodes, with inputs, outputs and dependencies, and no loops. You write it in YAML or build it in a drag-and-drop editor in the browser (binex ui).

A node is one of six types: an LLM agent, a local script, a human input, a human approval, a human output, or a remote agent that Binex reaches over A2A, a protocol for communication between agents. LLM nodes can use more than 40 providers through LiteLLM, including local models through Ollama. Components from LangChain, CrewAI and AutoGen can run as nodes through plugins. Each run is stored on your machine: a SQLite database holds the runs, execution records and costs, and each node's output is saved as a JSON artifact.

This makes Binex a small tool for AI orchestration with its own observability built in. The README closes with the aim behind it: "AI agents shouldn't be black boxes."

How do you find the step that went wrong?

From the command line:

• binex run workflow.yaml runs a workflow.
• binex debug <run_id> --node researcher shows the inputs and outputs of one node in a run.
• binex trace <run_id> shows the run as a timeline.
• binex diff compares two runs, and binex bisect finds the first node where they diverge.
• binex replay runs a workflow again from a chosen step, optionally with another agent for a node.
• binex cost show breaks the cost down per node.

The web interface shows the same views, and there you can swap the model or prompt of a single node and re-run just that node.

Where are the limits?

• It is a one-person project. On 23 September 2026, GitHub listed 650 commits by its creator, Alexli18, and one by another contributor; the repository had 62 stars and 11 forks. Version 0.8.0 appeared on 31 August 2026.
• Local applies to the runtime and the records. An LLM node still sends its prompt to the provider you configure; the README points to Ollama for fully local runs.
• The branching follows fixed rules on a node's output, while what an LLM node writes can differ from run to run. Comparing runs is what diff and bisect are for.

Example

The repository's human-in-the-loop example handles a pizza order. A script node builds the order, an approval node pauses the run until a person approves or rejects it, and a when condition decides whether the payment or the cancellation runs:

1
name: human-in-the-loop
2
nodes:
3
  builder:
4
    agent: "local://echo"
5
    system_prompt: "Build pizza order"
6
    inputs: {}
7
    outputs: [order]
8
  confirm_payment:
9
    agent: "human://approve"
10
    system_prompt: "Review and approve payment"
11
    inputs:
12
      order: "${builder.order}"
13
    outputs: [decision]
14
    depends_on: [builder]
15
  pay:
16
    agent: "local://echo"
17
    system_prompt: "Process payment"
18
    inputs:
19
      order: "${builder.order}"
20
    outputs: [receipt]
21
    depends_on: [confirm_payment]
22
    when: "${confirm_payment.decision} == approved"
23
  cancel:
24
    agent: "local://echo"
25
    system_prompt: "Cancel order"
26
    inputs: {}
27
    outputs: [cancellation]
28
    depends_on: [confirm_payment]
29
    when: "${confirm_payment.decision} == rejected"

The approval step is a human-in-the-loop gate. The post How do you build reliable multi-agent systems? shows Binex next to other tools from March 2026.