I built a private control room for coding agents running on my machines

SendLogz — Mon, 03 Aug 2026 12:33:30 +0000

I built a private control room for coding agents running on my machines

AI coding agents are good at working unattended. The awkward part starts when they need input: the terminal is on another laptop, a workstation, or a cloud VM, and the work is spread across SSH windows and tmux panes.

I built Wolfpack to solve that specific problem.

Wolfpack is a self-hosted browser and mobile command center for Claude Code, Codex CLI, Gemini CLI, and shell sessions. It runs on the machines where the agents already run. There is no Wolfpack account, hosted relay, or prompt-storage service. Remote access normally goes directly over a private Tailscale network.

The important design choice is that sessions belong to a persistent Rust PTY broker rather than the web server. Restarting or redeploying the dashboard does not have to kill the agents doing the work.

The workflow

Install Wolfpack on a machine running your coding agents.
Connect the machines and phone to the same Tailscale tailnet.
Scan the private HTTPS QR code printed during setup.
Open the PWA and see sessions across your machines.
Respond when an agent needs input, then leave it working.

curl -fsSL https://raw.githubusercontent.com/almogdepaz/wolfpack/main/install.sh | bash
wolfpack

What it is not

Wolfpack is not another coding agent, cloud workspace, or hosted orchestration platform. It is the control room around agents that are already running under your control.

That also means it is intentionally opinionated: self-hosted, local-first, and connected through infrastructure you choose. The current tradeoff is that deployment security still needs deliberate configuration before exposing it beyond a trusted private network.

Try it

The README has the demo, setup walkthrough, supported platforms, and troubleshooting guide. Feedback on installation and the two-machine workflow is more useful than stars: those are the parts I am trying to make boring.

Give Your AI Agent a Wallet in 5 Minutes (Without Risking Your Private Key)

SendLogz — Wed, 04 Mar 2026 21:58:38 +0000

Every AI agent wallet solution I've seen has the same problem: they give the agent a private key. One prompt injection, one hallucination, one bad tool call — and your funds are gone.

Clanker Wallet takes a different approach: the agent proposes transactions, the human reviews and signs them.

The Problem

You're building an AI agent that needs to:

Swap tokens on a DEX
Transfer funds
Interact with smart contracts

But you don't want to give it a private key. Because:

Prompt injections can trick agents into draining wallets
Agents hallucinate — they might send to the wrong address
You want to review transactions before they execute

The Solution

npm install -g clanker-wallet

Step 1: Connect your wallet

Go to clanker-wallet.xyz, connect your wallet (MetaMask, WalletConnect, etc.), and copy the pairing JSON.

Step 2: Pair your agent

clanker-wallet pair '{"version":1,"pubkey":"...","relay":"wss://...","wallet":"0x..."}'

This establishes an E2E encrypted channel between your agent and your browser. One-time setup.

Step 3: Send transactions

clanker-wallet tx \
  --chain 1 \
  --to 0xRecipientAddress \
  --value 1000000000000000 \
  --reason "Send 0.001 ETH to recipient"

This blocks until you approve or reject the transaction in the web app. You see:

Full transaction details
Simulation results
Risk flags
Decoded calldata

Using with LangChain

import { ClankerWallet } from 'clanker-wallet'
import { DynamicStructuredTool } from '@langchain/core/tools'
import { z } from 'zod'

const wallet = new ClankerWallet({ agentName: 'my-agent' })

const sendTx = new DynamicStructuredTool({
  name: 'send_blockchain_transaction',
  description: 'Send a blockchain transaction (requires human approval)',
  schema: z.object({
    chainId: z.number(),
    to: z.string(),
    value: z.string().default('0'),
    data: z.string().default('0x'),
    reason: z.string(),
  }),
  func: async ({ chainId, to, value, data, reason }) => {
    const txHash = await wallet.requestTx({
      chain_id: chainId,
      transaction: { to, value, data },
      context: { reason },
    })
    return `Approved: ${txHash}`
  },
})

Using with Vercel AI SDK

import { ClankerWallet } from 'clanker-wallet'
import { tool } from 'ai'
import { z } from 'zod'

const wallet = new ClankerWallet({ agentName: 'my-agent' })

const sendTx = tool({
  description: 'Send a human-approved blockchain transaction',
  parameters: z.object({
    chainId: z.number(),
    to: z.string(),
    value: z.string().default('0'),
    reason: z.string(),
  }),
  execute: async ({ chainId, to, value, reason }) => {
    const txHash = await wallet.requestTx({
      chain_id: chainId,
      transaction: { to, value, data: '0x' },
      context: { reason },
    })
    return { txHash }
  },
})

Using with Python

from clanker_wallet import ClankerWallet, Transaction, RequestTxOptions, TxContext

agent = ClankerWallet()
agent.pair(pairing_json)

tx_hash = await agent.request_tx(RequestTxOptions(
    chain_id=1,
    transaction=Transaction(to="0x...", value="1000000000000000", data="0x"),
    context=TxContext(reason="Send 0.001 ETH"),
))

How It Works Under the Hood

Pairing: Agent generates an x25519 keypair. Human's web app generates another. They exchange public keys.
Encryption: All messages use NaCl box (x25519-xsalsa20-poly1305). The WebSocket relay only sees encrypted blobs.
Approval: Human's browser decrypts the tx request, displays it with simulation data, and waits for approve/reject.
Signing: Human's wallet (MetaMask, etc.) signs the transaction. The signed tx is broadcast directly — the agent never sees the private key.

Security Model

Component	Trust Level
Agent	Untrusted (no private key)
Relay server	Untrusted (only sees encrypted data)
Human's browser	Trusted (has wallet access)
Communication	E2E encrypted

DEV Community: SendLogz

I built a private control room for coding agents running on my machines

I built a private control room for coding agents running on my machines

The workflow

What it is not

Try it

Give Your AI Agent a Wallet in 5 Minutes (Without Risking Your Private Key)

The Problem

The Solution

Step 1: Connect your wallet

Step 2: Pair your agent

Step 3: Send transactions

Using with LangChain

Using with Vercel AI SDK

Using with Python

How It Works Under the Hood

Security Model

Links