Kimi Code

Image updates

Ready-made agent images are updated every morning with the current CLI version. To keep a fixed image version, pin a template version.

Kimi Code is a Moonshot AI agent with tools for reading and writing files, executing commands, and searching. Use the kimi template to run the official CLI in a separate sandbox and retrieve results from your application.

Connect

Install the AgentBox SDK and set AGENTBOX_API_KEY.

The examples call moonshotai/kimi-k2.5 through OpenRouter. The application reads OPENROUTER_API_KEY and passes it to the CLI as KIMI_MODEL_API_KEY. KIMI_MODEL_PROVIDER_TYPE, KIMI_MODEL_BASE_URL, and KIMI_MODEL_NAME select the OpenAI-compatible protocol, OpenRouter endpoint, and model. These settings apply to the process invocation and do not require interactive login.

For model access, you can use the AgentBox HTTPS proxy https://sandbox-proxy.agentbox.ru:65181.

The examples pass HTTPS_PROXY, HTTP_PROXY, and NO_PROXY to the agent process. These settings may also affect other requests made by the agent and its child processes. Connections to localhost and 127.0.0.1 remain direct.

Draft a customer reply

The example supplies order details and asks Kimi to write a response draft to reply.md. The application retrieves the file through the filesystem SDK.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("kimi", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/request.txt",
    "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n",
  );
  const result = await sandbox.commands.run('kimi -p "$AGENT_PROMPT"', {
    cwd: "/home/user/work",
    timeoutMs: 300_000,
    envs: {
      HTTPS_PROXY: proxy,
      HTTP_PROXY: proxy,
      NO_PROXY: "localhost,127.0.0.1",
      AGENT_PROMPT:
        "Read request.txt and write reply.md with a short response to the customer.",
      KIMI_MODEL_API_KEY: apiKey,
      KIMI_MODEL_PROVIDER_TYPE: "openai",
      KIMI_MODEL_BASE_URL: "https://openrouter.ai/api/v1",
      KIMI_MODEL_NAME: "moonshotai/kimi-k2.5",
      KIMI_MODEL_MAX_CONTEXT_SIZE: "262144",
      KIMI_MODEL_CAPABILITIES: "tool_use",
    },
    onStderr: (chunk) => process.stderr.write(chunk),
  });
  console.log(result.stdout);
  console.log(
    "reply.md\n" + (await sandbox.files.read("/home/user/work/reply.md")),
  );
} finally {
  await sandbox.kill();
}

import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("kimi", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/request.txt",
        "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n",
    )
    result = sandbox.commands.run(
        'kimi -p "$AGENT_PROMPT"',
        cwd="/home/user/work",
        timeout=300,
        envs={
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
            "AGENT_PROMPT": "Read request.txt and write reply.md with a short response to the customer.",
            "KIMI_MODEL_API_KEY": api_key,
            "KIMI_MODEL_PROVIDER_TYPE": "openai",
            "KIMI_MODEL_BASE_URL": "https://openrouter.ai/api/v1",
            "KIMI_MODEL_NAME": "moonshotai/kimi-k2.5",
            "KIMI_MODEL_MAX_CONTEXT_SIZE": "262144",
            "KIMI_MODEL_CAPABILITIES": "tool_use",
        },
        on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
    )
    print(result.stdout)
    print("reply.md\n" + sandbox.files.read("/home/user/work/reply.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey := os.Getenv("OPENROUTER_API_KEY")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "kimi", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/request.txt", "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n", nil); err != nil {
		return err
	}
	result, err := sandbox.Commands.Run(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "kimi -p \"$AGENT_PROMPT\""},
		Cwd:  "/home/user/work",
		Env: map[string]string{
			"HTTPS_PROXY":                 proxy,
			"HTTP_PROXY":                  proxy,
			"NO_PROXY":                    "localhost,127.0.0.1",
			"AGENT_PROMPT":                "Read request.txt and write reply.md with a short response to the customer.",
			"KIMI_MODEL_API_KEY":          apiKey,
			"KIMI_MODEL_PROVIDER_TYPE":    "openai",
			"KIMI_MODEL_BASE_URL":         "https://openrouter.ai/api/v1",
			"KIMI_MODEL_NAME":             "moonshotai/kimi-k2.5",
			"KIMI_MODEL_MAX_CONTEXT_SIZE": "262144",
			"KIMI_MODEL_CAPABILITIES":     "tool_use",
		},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	fmt.Println(string(result.Stdout))
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/reply.md", "")
	if err != nil {
		return err
	}
	fmt.Println("reply.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

-p runs the task without the interactive UI. Regular tools run automatically without approval prompts in this mode. Separate --auto or --yolo flags are not needed. The prompt is passed through an environment variable and expanded inside quotes, preserving it as one shell argument.

The example reads the result before killing the sandbox. finally also releases it on error. The Go example uses a separate context for cleanup.

Events and session continuation

--output-format stream-json returns JSONL messages. The example displays answers and tool names, obtains the session ID, and supplies a delivery update in the same session.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.OPENROUTER_API_KEY;
if (!apiKey) throw new Error("OPENROUTER_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("kimi", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/request.txt",
    "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n",
  );
  async function execute(prompt, sessionId) {
    let pending = "",
      nextSessionId;
    function event(message) {
      if (message.role === "assistant") {
        if (message.content) console.log(message.content);
        for (const call of message.tool_calls ?? [])
          console.log("Tool:", call.function.name);
      }
      if (message.type === "session.resume_hint")
        nextSessionId = message.session_id;
    }
    function onStdout(chunk) {
      pending += chunk;
      let newline;
      while ((newline = pending.indexOf("\n")) !== -1) {
        const line = pending.slice(0, newline);
        pending = pending.slice(newline + 1);
        if (line.trim()) event(JSON.parse(line));
      }
    }
    await sandbox.commands.run(
      'kimi -p "$AGENT_PROMPT" --output-format stream-json' +
        (sessionId ? ' --session "$AGENT_SESSION_ID"' : ""),
      {
        cwd: "/home/user/work",
        timeoutMs: 300_000,
        envs: {
          HTTPS_PROXY: proxy,
          HTTP_PROXY: proxy,
          NO_PROXY: "localhost,127.0.0.1",
          AGENT_PROMPT: prompt,
          KIMI_MODEL_API_KEY: apiKey,
          KIMI_MODEL_PROVIDER_TYPE: "openai",
          KIMI_MODEL_BASE_URL: "https://openrouter.ai/api/v1",
          KIMI_MODEL_NAME: "moonshotai/kimi-k2.5",
          KIMI_MODEL_MAX_CONTEXT_SIZE: "262144",
          KIMI_MODEL_CAPABILITIES: "tool_use",
          AGENT_SESSION_ID: sessionId ?? "",
        },
        onStdout,
        onStderr: (chunk) => process.stderr.write(chunk),
      },
    );
    if (pending.trim()) event(JSON.parse(pending));
    if (!nextSessionId) throw new Error("Agent did not return a session ID");
    console.log("\nSession:", nextSessionId);
    return nextSessionId;
  }
  const sessionId = await execute(
    "Read request.txt and write reply.md with a short response to the customer.",
  );
  await execute(
    "Logistics has confirmed delivery on September 22, 2026 instead. Update reply.md with the new date.",
    sessionId,
  );
  console.log(
    "reply.md\n" + (await sandbox.files.read("/home/user/work/reply.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["OPENROUTER_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("kimi", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/request.txt",
        "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n",
    )

    def execute(prompt, session_id=None):
        pending = ""
        next_session_id = None

        def event(message):
            nonlocal next_session_id
            if message.get("role") == "assistant":
                if message.get("content"):
                    print(message["content"])
                for call in message.get("tool_calls", []):
                    print("Tool:", call["function"]["name"])
            if message.get("type") == "session.resume_hint":
                next_session_id = message.get("session_id")

        def on_stdout(chunk):
            nonlocal pending
            pending += chunk
            while "\n" in pending:
                line, pending = pending.split("\n", 1)
                if line.strip():
                    event(json.loads(line))

        sandbox.commands.run(
            'kimi -p "$AGENT_PROMPT" --output-format stream-json'
            + (' --session "$AGENT_SESSION_ID"' if session_id else ""),
            cwd="/home/user/work",
            timeout=300,
            envs={
                "HTTPS_PROXY": proxy,
                "HTTP_PROXY": proxy,
                "NO_PROXY": "localhost,127.0.0.1",
                "AGENT_PROMPT": prompt,
                "KIMI_MODEL_API_KEY": api_key,
                "KIMI_MODEL_PROVIDER_TYPE": "openai",
                "KIMI_MODEL_BASE_URL": "https://openrouter.ai/api/v1",
                "KIMI_MODEL_NAME": "moonshotai/kimi-k2.5",
                "KIMI_MODEL_MAX_CONTEXT_SIZE": "262144",
                "KIMI_MODEL_CAPABILITIES": "tool_use",
                "AGENT_SESSION_ID": session_id or "",
            },
            on_stdout=on_stdout,
            on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
        )
        if pending.strip():
            event(json.loads(pending))
        if not next_session_id:
            raise RuntimeError("Agent did not return a session ID")
        print("\nSession:", next_session_id)
        return next_session_id

    session_id = execute(
        "Read request.txt and write reply.md with a short response to the customer."
    )
    execute(
        "Logistics has confirmed delivery on September 22, 2026 instead. Update reply.md with the new date.",
        session_id,
    )
    print("reply.md\n" + sandbox.files.read("/home/user/work/reply.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey := os.Getenv("OPENROUTER_API_KEY")
	if apiKey == "" {
		return errors.New("OPENROUTER_API_KEY is required")
	}
	proxy := os.Getenv("SANDBOX_PROXY_URL")
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "kimi", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/request.txt", "Customer Acme asks when order 1042 will arrive. Order 1042 shipped on September 18, 2026. Estimated delivery is September 21, 2026. Tracking number: AB1042.\n", nil); err != nil {
		return err
	}
	execute := func(prompt, sessionID string) (string, error) {
		var pending, nextSessionID string
		var streamErr error
		event := func(line string) {
			if strings.TrimSpace(line) == "" || streamErr != nil {
				return
			}
			var message struct {
				Type      string `json:"type"`
				Role      string `json:"role"`
				Content   string `json:"content"`
				SessionID string `json:"session_id"`
				ToolCalls []struct {
					Function struct {
						Name string `json:"name"`
					} `json:"function"`
				} `json:"tool_calls"`
			}
			if err := json.Unmarshal([]byte(line), &message); err != nil {
				streamErr = err
				return
			}
			if message.Role == "assistant" {
				if message.Content != "" {
					fmt.Println(message.Content)
				}
				for _, call := range message.ToolCalls {
					fmt.Println("Tool:", call.Function.Name)
				}
			}
			if message.Type == "session.resume_hint" {
				nextSessionID = message.SessionID
			}
		}
		command := "kimi -p \"$AGENT_PROMPT\" --output-format stream-json"
		if sessionID != "" {
			command += " --session \"$AGENT_SESSION_ID\""
		}
		commandCtx, stop := context.WithTimeout(ctx, 5*time.Minute)
		defer stop()
		_, err := sandbox.Commands.Run(commandCtx, "sh", &agentbox.CommandOptions{
			Args: []string{"-lc", command},
			Cwd:  "/home/user/work",
			Env: map[string]string{
				"HTTPS_PROXY":                 proxy,
				"HTTP_PROXY":                  proxy,
				"NO_PROXY":                    "localhost,127.0.0.1",
				"AGENT_PROMPT":                prompt,
				"KIMI_MODEL_API_KEY":          apiKey,
				"KIMI_MODEL_PROVIDER_TYPE":    "openai",
				"KIMI_MODEL_BASE_URL":         "https://openrouter.ai/api/v1",
				"KIMI_MODEL_NAME":             "moonshotai/kimi-k2.5",
				"KIMI_MODEL_MAX_CONTEXT_SIZE": "262144",
				"KIMI_MODEL_CAPABILITIES":     "tool_use",
				"AGENT_SESSION_ID":            sessionID,
			},
			OnStdout: func(chunk []byte) {
				pending += string(chunk)
				for {
					line, rest, found := strings.Cut(pending, "\n")
					if !found {
						break
					}
					pending = rest
					event(line)
				}
			},
			OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
		})
		if err != nil {
			return "", err
		}
		event(pending)
		if streamErr != nil {
			return "", streamErr
		}
		if nextSessionID == "" {
			return "", errors.New("agent did not return a session ID")
		}
		fmt.Println("\nSession:", nextSessionID)
		return nextSessionID, nil
	}
	sessionID, err := execute("Read request.txt and write reply.md with a short response to the customer.", "")
	if err != nil {
		return err
	}
	if _, err := execute("Logistics has confirmed delivery on September 22, 2026 instead. Update reply.md with the new date.", sessionID); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/reply.md", "")
	if err != nil {
		return err
	}
	fmt.Println("reply.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

Messages with role: assistant contain text in content and calls in tool_calls. Tool results arrive with role: tool. The final session.resume_hint provides session_id, which the example passes to --session. This streams messages and tool results rather than individual tokens. The process must exit successfully before the application reads the output file.

Session history and files are stored in the sandbox. For another call, keep it and the session ID, or pause it. The full protocol and CLI options are described in the Kimi Code reference.

Kimi Code ​

Connect ​

Draft a customer reply ​

Events and session continuation ​

Kimi Code

Connect

Draft a customer reply

Events and session continuation