floatboat
Open navigation menu

Kimi Code CLI

Study Kimi Code CLI’s tool loop, focused subagents, lifecycle hooks, and editor protocol as references for your own workflows. Use them to clarify task roles, execution checks, and context handoffs around work in Floatboat.

Plan an editor-to-agent review handoff

Bring a development task whose roles or editor handoffs are unclear. The request can compare Kimi Code's tool feedback and lifecycle boundaries, defining the context and result each stage needs before proposing an adapter or changing the execution workflow.

Name the editor, selected files, review scope, and required return format.

Copy the request into a new Floatboat conversation and provide the required material.

Download Floatboat

Your request for Floatboat

Preview and copy the request. It is not sent automatically from this page.

Reference: Kimi Code CLI
https://github.com/MoonshotAI/kimi-code

Read the original documentation and check the current environment and dependencies. Propose any new installation or tool connection before proceeding.

My task:
Read Kimi Code’s ACP documentation and assess a review handoff from my editor. I want selected files and acceptance criteria sent as one task, with findings returned against code locations. Verify compatibility first and propose the smallest test.

Expected deliverable:
An interface compatibility check and a handoff format for context, findings, and verification.

About Kimi Code CLI

Kimi Code CLI is Moonshot AI’s current open-source coding agent for the terminal. Its official description includes reading and editing code, running commands, searching files, and fetching web pages, with the agent choosing subsequent steps from tool feedback. It is an application around the model, not a Skill package.

For a Floatboat user improving a workflow, the useful ideas are role separation, explicit tool feedback, and well-defined points for checks. Kimi Code CLI provides a concrete reference for those mechanisms. ACP also illustrates how an interface can remain separate from the process that executes an agent task.

The maintained repository is MoonshotAI/kimi-code and uses MIT. The earlier Python project, MoonshotAI/kimi-cli, was archived and directs users to the newer CLI. Keep that distinction in mind when reading tutorials: the old project’s architecture, package names, and instructions are not interchangeable with the current release.

Workflow Mechanisms to Learn From

Kimi Code's tool-feedback loop, delegated responsibilities, and lifecycle checks solve different coordination problems. Review their interfaces as parts of an execution design, with the context and review evidence each role must return made explicit before tasks move between stages.

  • An explicit tool-feedback loop

    Study how a task continues from command and file results, then define the evidence your own workflow needs at each step.

  • Focused task responsibilities

    Use subagent contexts as a reference for dividing exploration, planning, and implementation without losing the parent task’s goal.

  • Checks at lifecycle boundaries

    Study hooks and interface protocols when deciding where to validate an action and how context should pass between tools.

Use Cases for Kimi Code CLI

Role delegation, pre-action checks, and editor handoffs create different coordination requirements. Explore Kimi Code's interface and runtime boundaries while defining each role's output, review point, and context contract before testing compatibility with your existing environment.

A multi-role coding workflow

A coding workflow can divide research, planning, and implementation into distinct roles. Define each role's inputs, inspectable outputs, and handoff conditions within the same development task. Include the conditions for returning findings to the main task so parallel contributions do not become disconnected assignments.

Checks before consequential steps

Before a consequential command, file change, or external action, decide what evidence is needed to assess its impact. Place a validation or human review point there and return the result to the workflow. Whether execution continues or stops should follow the applicable authorization and the check's actual findings.

A consistent context handoff

A workflow spanning an editor, workspace, and agent process needs a clear context contract between them. Use the interface–runtime separation to map workspace paths and task information to the execution process. Verify the ACP or other interface handoff rather than assuming a client supports the required behavior natively.

Evaluate a lifecycle check before adoption

A hook or plugin intended to inspect a consequential step needs its own bounded trial. Compare the maintained Kimi Code documentation with the surrounding runtime and describe what the check receives, returns, and does when it cannot decide. Verify that its feedback reaches the main workflow without assuming that merely installing an extension creates the approval policy your project requires.

Use the current Kimi Code reference

The maintained kimi-code reference and legacy Python CLI examples may describe different architectures. Establish which version the investigation concerns before reusing delegation or context mechanisms, and read the matching documentation rather than combining incompatible examples into one setup.

  • Use the maintained reference

    Use kimi-code documentation when studying the mechanisms; legacy Python CLI examples can describe a different architecture.

Verify delegated work in Kimi Code

Delegated coding work should preserve enough context for the next role without passing unrelated history. Define the handoff contract and review point for each contribution, then verify that the receiving stage can use the actual material before extending the workflow.

  1. Define each role and checkpoint

    Specify what each delegated task receives, what it returns, and which operation must wait for review.

  2. Test the context transfer

    Check whether each stage gets enough relevant information without carrying unrelated conversation history into every step.

Related Software Projects

Compare the workflows, operating requirements, and source licenses of these projects.

Kimi Code CLI FAQ

Which Kimi repository is current?
Use MoonshotAI/kimi-code for Kimi Code CLI. MoonshotAI/kimi-cli is the archived Python implementation and explicitly directs users to the current project.
Is Kimi Code CLI an independent agent project?
Yes. It includes an interactive application, tools, sessions, and agent execution. It is not just a prompt, a model, or a collection of Skills, even though Skills can extend its workflows.
Can it use a provider other than Kimi?
The README says other compatible providers can be configured. Verify the provider’s protocol and feature support rather than assuming that every model endpoint behaves identically.
What does ACP integration provide?
It allows compatible editors to drive a Kimi Code CLI session over the Agent Client Protocol. The editor supplies its interface while the CLI handles the agent session; the editor must support the integration.
Must I switch products to use these workflow ideas?
No. You can first use Kimi Code CLI as a reference for task structure, tool boundaries, and result review in your existing workflow. Reusing software is a separate choice that requires compatibility, permissions, and license checks; applying the design ideas does not automatically connect the software to Floatboat.
Does MIT cover a Kimi subscription?
No. MIT applies to the project source. Kimi Code account access, Moonshot API use, and any other provider’s service are governed by their own entitlements, limits, and terms.