GitHub
Alpha Source-available, BSL 1.1

The Agent IDE.

Build, debug, and ship AI agents visually. Design multi-agent systems on a drag-and-drop canvas, debug with breakpoints and time-travel, and deploy as one zero-dependency binary.

rakit (Indonesian: craft) + jiritsu (Japanese: autonomous) = autonomous assembly

Install Rakitsu View on GitHub
$ curl -fsSL https://raw.githubusercontent.com/SK-ENT/rakitsu/main/install.sh | sh
TTreeBBlock
LiveHistory
1 active
Running... 41.2s 220 tokens DEBUG
PipelineAgentToolCustom
||Paused at Reviewer (pre_tool)iter 0/10, 0.2K tokens
▶ ResumeStepStep InStep OutRun Until■ Stop pre_tool @ Reviewer x
Filter by agent or label...
▼PRUN: Review internal/auth (1 steps)
▼Sreview [sequential]
Starting...
▼❚❚ReviewerPAUSEDBPRT
Working...
▼#Iteration 0
TThought8.5s
HHandoff to Reviewer
agent: Reviewerx
Token usageTokenize
184Input
36Output
220Total
Input
Roleworker
Provideropenai
Modelgpt-4o
Toolsread_file
Run to here Pause at agent: Reviewer, AGENT_START
Pause context
PRE_TOOL
Tokens in184
Tokens out36
Iteration0 / 10
History2 messages
Pending tool calls
▼read_file
{
  "path": "internal/auth/auth.go"
}
TreeBlock
LiveHistory
Running... 41s DEBUG
||Paused at Reviewer (pre_tool)iter 0/10
▶ ResumeStepStep In■ Stop pre_tool @ Reviewer
▼PRUN: Review internal/auth
▼Sreview [sequential]
▼❚❚ReviewerPAUSED
Working...
▼#Iteration 0
TThought8.5s
HHandoff to Reviewer
Pending tool calls
▼read_file
{ "path": "internal/auth/auth.go" }

Visual-first

Design agents on a drag-and-drop canvas, not in code.

Debug like software

Breakpoints, pause, inspect reasoning mid-execution.

Single binary

One file, zero dependencies. Download and run.

YAML-configured

Declarative configs. No framework code to write.

Multi-provider

Mix OpenAI, Anthropic, Gemini, and Ollama per agent in one config.

One binary. Builder, debugger, and engine.

Everything below ships in the file you just downloaded. No plugins, no services, no framework code.

Visual Builder

  • Drag agents onto the canvas, wire tools, group into pipelines
  • Pipeline, parallel, and team groups
  • Groups set defaults, agents override them, badges show which
  • Canvas search, auto-arrange, hierarchy panel

Runtime Debugger

  • Breakpoints on any agent or tool node
  • Pause mid-run, inspect reasoning, override parameters, resume
  • Tree, block diagram, timeline, and mind-map views
  • Scrub back through completed runs

Agent Engine

  • ReAct loop with reflection and ground-checking
  • Sequential, parallel, hierarchical, DAG, and plan-and-execute strategies
  • Pipeline checkpoint and resume
  • Token budgets, cost tracking, context auto-compression

Providers

  • OpenAI, Anthropic Claude, Google Gemini, Ollama, LiteLLM
  • Mix providers per agent in a single config
  • Auto-discover models from any OpenAI-compatible endpoint
  • Swap provider and model at run time with a flag

Protocols

  • ACP server, so editors like Zed talk to your agents directly
  • MCP server at /mcp for external clients
  • A2A endpoint at /a2a with agent-card discovery
  • Call out to other MCP servers and A2A agents as tools

Operations

  • Session history with replay and rerun
  • CLI and web UI modes
  • Sandboxed tools: command allowlist, path restrictions, Docker
  • Linux, macOS, and Windows on amd64 and arm64
IN ACTION

Watch a run pause at a breakpoint, then talk to the same agents.

Three short clips recorded against Rakitsu v0.2.0-alpha.3 with a local model. Nothing staged: the README's Code Reviewer config, a breakpoint on the tool, a chat that hands the work to the pipeline, and the same run watched from a terminal and a browser at once.

Three short clips recorded against Rakitsu v0.2.0-alpha.3 with a local model. Nothing staged.

0:26
Debugger Import the config, set a breakpoint on read_file, run with Debug. The tree pauses at pre_tool; inspect token usage and the pending call, then resume to the result.
0:15
Chat Open a chat on the same config. The chat host delegates the review to the pipeline, shows the nested tool calls, and comes back with the three real bugs in sample.go.
0:15
TUI + Web, side by side The exact same run, watched two ways at once: a plain rakitsu run --interactive in a terminal on the left, its live execution tree filling in in the web Debugger on the right.
WALLPAPERS

Something to watch while an agent thinks.

The Builder canvas can run an animated shader behind your agents — seven presets, off by default, one keypress away. One of them is a koi pond you can actually feed.

KOI POND
Water — yes, it's a koi pond Press F to drop pellets, the koi come feed; press again to fish instead. This clip is the real thing: an agent paused mid-run in the background, koi doing their own thing in the foreground. Somebody's kid was right — it beats staring at a spinner.
Circuit Flow
Plasma Lattice
Volumetric Fog
Voronoi Cells
Aurora Waves
Suminagashi

Up and running in three commands.

  1. 1

    Install

    Linux and macOS. Windows builds are on the releases page.

    curl -fsSL https://raw.githubusercontent.com/SK-ENT/rakitsu/main/install.sh | sh

    That's the latest stable release. For the newest commits on main (nightly, may be unstable):

    go install github.com/SK-ENT/rakitsu/cmd/rakitsu@main
  2. 2

    Create a project

    An interactive wizard writes the config and a first agent for you.

    rakitsu quickstart
  3. 3

    Open the canvas

    Then open http://localhost:9100. Drag agents onto the canvas, wire up tools, hit Run.

    rakitsu serve
code-review.yaml
name: Code Reviewer
settings:
  default_provider: openai
  providers:
    openai:
      type: openai
      api_key: ${OPENAI_API_KEY}
  defaults:
    model: gpt-4o-mini

tools:
  - name: read_file
    type: fs
    operation: read

agents:
  - name: Reviewer
    role: worker
    provider: openai
    model: gpt-4o
    system_prompt: Review code for bugs, security issues, and best practices.
    tools: [read_file]

orchestrator:
  name: Lead
  strategy: Pipeline
  agents: [Reviewer]
name: Code Reviewer
settings:
  default_provider: openai
  providers:
    openai:
      type: openai
      api_key: ${OPENAI_API_KEY}

tools:
  - name: read_file
    type: fs
    operation: read

agents:
  - name: Reviewer
    role: worker
    model: gpt-4o
    system_prompt: Review code for bugs and security issues.
    tools: [read_file]

orchestrator:
  name: Lead
  strategy: Pipeline
  agents: [Reviewer]

Swap the provider at run time without touching the file:

rakitsu run code-review.yaml "review internal/auth" --provider ollama --model llama3

Where it comes from

Rakitsu began in spring 2026 as a small project to support my son. It was supposed to stay small. It didn't. The problem turned out to be genuinely interesting, and it grew into serious, long-term work. It remains a family project at heart.

Rakitsu is built openly with AI. Design decisions, code review, and final verification are human; a large share of the implementation is AI-assisted. How AI tooling relates to the license

Source-available under the Business Source License 1.1.

Free for personal, internal, educational, and research use. Each release converts to Apache 2.0 four years after it ships. Hosting or embedding Rakitsu in a competing product needs a commercial license.

Commercial licensing