Open Source Control Plane

The Secure Agentic Control Plane

Run autonomous TDD actor-critic loops in the cloud while pulling credentials dynamically and securely from your local machine over a reverse tunnel. **Safely close your laptop** while Kiwi executes.

$ go install github.com/runkiwi/kiwi/cmd/kiwi@latest
Simulation:

The Secure Control Plane in Action

Explore Kiwi's complete orchestration engine. Select a sandbox, trigger system controls, and observe multi-agent sandboxing, tunneling, budget caps, and safety breakers.

Control Plane: ONLINE
Sandboxes: 3 Active
Active Tunnels: 2 / 3 Connected
task-3831 RUNNING
steelwing (TDD loop)

Fix division by zero inside Divide()

Golang • Docker v1.21
task-3832 PAUSED
microfish (secrets tunnel)

Upload credentials & test S3 pipeline

Python • Boto3 Sandbox
task-3833 RUNNING
threatmapper (safety cap)

Loop refactoring & security checks

Node.js • Scanner Engine
SANDBOX: task-3831 (steelwing) RUNNING
Local Laptop Connected
REVERSE TUNNEL
Docker Sandbox Active Loop
In-Memory Cache:
GITHUB_TOKEN DATABASE_URL AWS_SECRET
Safety Budget Cap:
$1.50 spent $10.00 Limit
Circuit Breaker:
STABLE (No loops)

Trigger Controls

Trigger system actions on the active sandbox.

Client Laptop Connection
TDD Actor-Critic alignment
Safety & Security Systems

Built for Enterprise Agent Workflows

Secure, resilient execution that bridges the speed of the cloud with the compliance of local keys.

Actor-Critic Loop

A test-driven controller that edits code, evaluates compiler and test output inside the sandbox container, and refines fixes iteratively until resolution.

Docker Sandboxing

Isolates all untrusted code modification, compiling, and unit testing inside dedicated Docker containers (`golang:alpine`), protecting the parent host.

Reverse Tunneling

Eliminates the risk of persisting long-lived GitHub tokens, database keys, or cloud access roles on remote sandbox instances. Pull credentials dynamically as needed.

In-Memory Secret Caching

Enables complete laptop closure. Once a secret is queried through the tunnel, it is cached in-memory securely to let the loop execute autonomously to completion.

Stateful Pause & Resume

Complete offline resilience. If the loop requests a new, uncached secret while your laptop is closed, it pauses execution statefully and resumes once you reconnect.

Budget Caps & Safety

Integrated circuit breakers detect infinite loop structures by tracking duplicate terminal output hashes. Budget caps limit token overhead to guarantee cost-controls.

Interactive Kanban Control Board

Monitor your agent's loops, debug stack traces, edit budgets, and manage offline sessions in real-time.

https://dashboard.runkiwi.dev

Agent Tasks

4 Running Sandbox Containers
PAUSED (Awaiting Reconnect) 1
task-3829

Fix AWS S3 client bucket upload issue

AWS_SECRET_ACCESS_KEY missing (Tunnel Offline)
RUNNING (Actor-Critic Loops) 2
task-3831

Resolve nil pointer error in database connector

[TDD-Loop #3] Running `go test ./pkg/db...` (Passed 14/15)
task-3830

Refactor endpoints to support pagination

[TDD-Loop #1] Analyzing compiler stdout errors...
RESOLVED 1
task-3825

Fix divide by zero inside AverageCalculation

Success. Fixed code saved to zip package.

Get Started in 60 Seconds

Configure the Kiwi daemon host and deploy your first agent task with minimal overhead.

Host Machine Terminal (Server/VPS)
# Build Kiwi binaries
go build -o kiwid cmd/kiwid/main.go

# Start the daemon on port 8080 (Set secure token)
export USE_DOCKER="true"
export KIWI_SERVER_TOKEN="production-secure-token-9999"

./kiwid -addr :8080 -db kiwi.db
Local Machine Terminal (Developer CLI)
# Set up your local secrets structure
echo '{"GITHUB_TOKEN": "ghp_secureTokenValue"}' > secrets.json

# Submit the task to the cloud and establish reverse secrets tunnel
kiwi -server "http://kiwi-daemon.yourhost.com:8080" \
     -token "production-secure-token-9999" \
     -task "Fix division by zero in Divide()" \
     -file math_utils.go \
     -test-cmd "go test ./..."

Ready to secure your agentic execution?

Deploy the control plane to your own infrastructure or start developing locally.