tentacle

tentacle attach

Debug where the bug lives.

Attach to a pod that is already running and the agent sees what your service sees: in-cluster DNS, the real config, the services next door. There is nothing to reproduce locally.

Close the TUI and you detach. The pod keeps running.

tentacle · attach checkout-7d9f

$ tentacle attach checkout-7d9f -n staging

› checkout returns 502 in staging, why?

⏺ Bash curl -sS http://payments:8000/health 0.1s
⎿ exit=7
  curl: (7) Failed to connect to payments port 8000

⏺ Bash curl -sS http://payments:8080/health 0.1s
⎿ exit=0
  {"status":"ok"}

⏺ Bash printenv PAYMENTS_URL 0.0s
⎿ exit=0
  http://payments:8000

⏺ payments listens on 8080, but checkout calls it on
  8000: PAYMENTS_URL in the staging overlay still has
  the old port.

›

tentacle serve · tentacle connect

Run it on the big box. Drive it from your laptop.

Start tentacle as a daemon on a build server or a GPU machine, then connect your TUI to it over WebSocket. Shell commands, builds and tests run on that machine.

$ tentacle serve --host 203.0.113.10 \
    --tls-cert cert.pem --tls-key key.pem \
    --token-command "cat ~/.config/tentacle/token"

Approvals come to you. Every permission prompt travels back to the TUI on your laptop.
Steer mid-turn. Queue a message while the agent works, without stopping it.
Locked down off loopback. A public bind requires a bearer token. TLS is built in.

tentacle · connect 203.0.113.10

$ tentacle connect wss://203.0.113.10:4000 \
    --token-command "cat ~/.config/tentacle/token"

› build the release and run the full test suite

⏺ Bash nproc 0.0s
⎿ exit=0
  64

⏺ Bash make -j64 release 192.4s
⎿ exit=0
  built dist/server (412 MB)

⏺ Bash make -j64 test 108.0s
⎿ exit=2
  1838 passed, 2 failed (pkg/cache)

⏺ Built and tested on the 64-core box in five
  minutes. Two failures, both in pkg/cache.
  Want me to look into them?

›

Why tentacle

One agent, wherever the work is.

The same agent loop and the same TUI, whether the code is on your machine, in a cluster, or on a box across the world.

Any model

Point it at any OpenAI-compatible endpoint, like a local llama.cpp or vLLM server or a hosted API, or use the native Anthropic Messages API. One line in config.jsonc.

Runs anywhere

On your laptop, in a fresh Kubernetes pod, inside a pod that already exists, or as a daemon you connect to remotely. Every mode drives the same TUI.

Safe by default

File writes stay inside the workspace, with symlink escapes refused. Shell commands go through a permission engine that never auto-approves command substitution.

tentacle run · tentacle attach

Compute next to the code. Identity with you.

Start the agent in a sandbox pod with run, or drop it into a pod you already have with attach. The pod does the work. Your laptop keeps everything that is yours.

The pod workspace

Your code, toolchain and build caches
Shell commands and background jobs
MCP servers that act on the workspace
Close to the services it needs: databases, queues, the cluster network

Your laptop identity

The model endpoint and API key: model calls are tunnelled back through you
Every permission decision, answered in your TUI
Session history, saved locally, so --resume just works
Cluster auth from your kubeconfig, with no kubectl needed

The pod is not trusted. Anything it asks your laptop to do is checked on your laptop and approved by you. A pod can never turn its own request into a lasting approval. run deletes its pod when you exit, even on Ctrl+C. attach never creates or deletes anything.

Inside

Built for long, real sessions.

A terminal UI that keeps up

Streaming output, full-width diffs with word-level highlights, mouse scroll and selection, multi-line input, a slash-command palette.

Off the render thread

The agent loop and tools run in a separate worker, so typing and scrolling stay smooth while the model works.

Background jobs

Long builds and servers run in the background. When a job exits, the agent picks up the result on its own.

Sub-agents

Hand focused work to isolated child agents, built in or defined by you in Markdown.

MCP

Connect Model Context Protocol servers. Their tools sit next to the built-in ones, also over RPC and in pods.

Context compaction

Run /compact to summarise a long conversation and keep going without losing the thread.

Resume anything

Every session is saved. tentacle --resume picks up the latest one, locally or in a pod.

Knows your repo's rules

Loads your project's AGENTS.md into the prompt automatically.

One binary

Compiles to a single self-contained executable, the same one that tentacle injects into pods.

Get started

Two minutes to a working agent.

Install. One binary for macOS or Linux, no sudo. It goes in ~/.local/bin. $ curl -fsSL tentacle.so/install | sh
Run it once. tentacle creates ~/.config/tentacle/ with a config.jsonc that documents itself.
Point it at a model. Add the base URL of your provider, a model id and your API key.
Start working. Run tentacle for the TUI, or tentacle "<task>" for a one-shot run.

~/.config/tentacle/config.jsonc

{
  "model": {
    "baseURL": "http://localhost:8080/v1",
    "model": "my-model",
    "apiKey": "your-api-key"
  }
}