To get real work out of Kimi's Agent Mode, do two things: switch on Agent Mode (OK Computer) for anything with a concrete deliverable, and structure the prompt as Goal → Deliverable → Context → Constraints → Checkpoints. State the outcome, name the exact artifact you want back, paste every input up front, list the hard rules, and tell Kimi what to confirm before it finishes. Kimi is Moonshot AI's free assistant at kimi.com, running the K2.7 / K2 family — a 1-trillion-parameter mixture-of-experts model (~32B active) with a 256K context window and multimodal input. Agent Mode plans and builds Websites, Docs, Slides, and Sheets across many coordinated steps, and can dispatch an Agent Swarm of specialized sub-agents.
This guide covers the five-part agentic formula, when to pick Instant vs Thinking vs Agent Mode, the mistakes that quietly derail an agent run, and ten copy-paste prompts. For the broader set, start with the best Kimi prompts roundup, and keep the Kimi prompt cheat sheet open as a one-pager.
The agentic formula: Goal → Deliverable → Context → Constraints → Checkpoints
An agent runs many steps without you watching, so a vague target compounds into a wrong result. The fix is to fix the target. Every strong Agent Mode prompt has the same five parts — the key insight is that you specify the exact deliverable and its acceptance criteria and hand over all inputs before the run starts, so Kimi never has to guess halfway through.
| Part | What it is | Example |
|---|---|---|
| Goal | The outcome you want, in one plain sentence. The "why," not the steps. | "Launch a waitlist page for my new app." |
| Deliverable | The exact artifact — file type, format, length, sections. This is what "done" looks like. | "A single responsive HTML page with a hero, three feature blocks, and an email capture." |
| Context / inputs | Every input up front: copy, data, brand, files, links. Paste or upload it all now. | "Product name, one-liner, feature list, and logo (attached)." |
| Constraints | The hard rules the result must satisfy — style, limits, tools, what to avoid. | "Mobile-first, no external JS libraries, brand color #1a73e8." |
| Checkpoints | What Kimi should confirm or return at the end — and where to pause for a decision. | "Show me the layout plan before building; at the end, list what you built and any assumptions." |
Here is the difference the formula makes. Before, a thin prompt that leaves the agent guessing:
Make me a landing page for my app.After, the same task run through the formula in Agent Mode:
Goal: Launch a waitlist landing page for my new app so I can start collecting signups.
Deliverable: One responsive HTML page (single file) with a hero headline + subhead, three feature blocks with icons, a short FAQ, and an email capture form. Include the CSS inline.
Context: App name: [NAME]. One-liner: [ONE-LINER]. Three features: [FEATURE 1], [FEATURE 2], [FEATURE 3]. Brand color: [HEX]. Tone: [TONE]. Logo attached.
Constraints: Mobile-first, loads without external JS libraries, accessible (labels + alt text), copy under 400 words total.
Checkpoints: First show me the section layout and headline options and wait for my OK. Then build. At the end, list every section you created and any assumption you made.The second prompt names the exact file, hands over every input, sets the guardrails, and adds a checkpoint so you approve the direction before Kimi spends steps building the wrong thing.
When to use Instant vs Thinking vs Agent Mode
Kimi gives you three gears. Picking the right one matters more than any wording trick.
- Instant — fast answers with no visible planning. Use it for lookups, short rewrites, quick questions, and one-shot drafts. If a single reply would finish the job, stay here.
- Thinking — deeper reasoning that catches missing requirements and edge cases before it commits. Use it for hard logic, tricky code, or when you want Kimi to pressure-test a plan. It's the mode that says "you didn't specify what happens when the list is empty" before writing the bug.
- Agent Mode (OK Computer) — autonomous plan-and-build across many steps and tool calls, producing Websites, Docs, Slides, and Sheets, with an Agent Swarm of sub-agents for larger jobs. Use it when the task has a concrete deliverable that takes real multi-step work — a site, a deck, a tracker, a scrape-and-report, a small app.
Rule of thumb: if the answer is words, use Instant or Thinking; if the answer is an artifact — a file, a built thing, a run of coordinated steps — use Agent Mode. Turn on Web search / Deep Research when the task needs live or cited facts, and upload files or images so Kimi works from the real inputs instead of a paraphrase. For agent-specific patterns, see Kimi agent prompts.
Mistakes to avoid
- Naming a vague deliverable. "Make a report" gives the agent nothing to build toward. Name the file, length, and sections so it has a fixed target and acceptance criteria.
- Feeding inputs in dribs and drabs. An agent that gets data halfway through has to rework earlier steps. Paste or upload every input before the run starts.
- No checkpoints on a long task. Without a "show me the plan first" pause, Kimi may spend many steps in the wrong direction. Add a checkpoint before the expensive part.
- Using Instant for a multi-step build. A concrete artifact needs Agent Mode. Instant will hand back a description, not the thing.
- Skipping constraints. Without hard rules (tools, style, limits), the agent picks its own — and you inherit choices you didn't want. State them up front.
- No live-data toggle for current facts. If the task depends on today's data, turn on Web search or Deep Research or the agent reasons from stale memory.
10 agent prompts to copy
Run each of these in Agent Mode (OK Computer) unless noted. Swap anything in [BRACKETS] for your own details, and paste or upload your real content where noted.
1. Build a landing page
Goal: Launch a marketing landing page for [PRODUCT].
Deliverable: One responsive HTML file with inline CSS — hero (headline + subhead + CTA button), three feature blocks, a testimonial strip, and an email capture form.
Context: Product one-liner: [ONE-LINER]. Features: [LIST]. Brand color: [HEX]. Tone: [TONE]. Logo/images attached.
Constraints: Mobile-first, no external JS libraries, accessible labels and alt text.
Checkpoints: Show me the section layout and three headline options first; wait for my pick, then build. At the end, list the sections and any assumptions.Note: The layout-first checkpoint stops Kimi from committing to a hero you'd have rewritten anyway.
2. Build a slide deck
Goal: Create an investor pitch deck for [COMPANY].
Deliverable: A 10-slide Slides deck: cover, problem, solution, product, market size, business model, traction, competition, team, ask.
Context: What we do: [PASTE]. Traction numbers: [PASTE]. Market notes: [PASTE]. Ask amount: [AMOUNT]. Brand color: [HEX].
Constraints: One idea per slide, max 30 words of body text per slide, use our brand color for accents, no clip-art.
Checkpoints: Draft the slide-by-slide outline first and wait for my OK before designing. Flag any slide where you're missing a number.Note: Fixing the slide count and one idea per slide keeps the deck tight instead of a wall of bullets.
3. Build a tracker sheet / dashboard
Goal: Build a tracker to manage [WHAT — e.g., job applications / content calendar / expenses].
Deliverable: A Sheet with columns [LIST COLUMNS], data validation on [STATUS COLUMN], a summary tab with counts by status, and a simple chart of [METRIC] over time.
Context: Sample rows to model the structure: [PASTE 3-5 ROWS]. How I'll use it: [WORKFLOW].
Constraints: Formulas must auto-update, no manual recalculation, keep it usable on mobile.
Checkpoints: Confirm the column list and the summary metrics with me before building. Return a one-line note on how to add new rows.Note: Giving sample rows lets Kimi infer types and validation instead of guessing your data shape.
4. Research-and-report agent
Goal: Give me a decision-ready briefing on [TOPIC/QUESTION].
Deliverable: A Doc (~1,200 words) with an executive summary, 4-6 findings each with a cited source, a risks section, and a clear recommendation.
Context: Why I'm asking: [DECISION I FACE]. What I already know: [PASTE]. Sources to prioritize or avoid: [LIST].
Constraints: Turn on Web search / Deep Research. Every factual claim needs a linked source and a date. Flag anything you couldn't verify.
Checkpoints: List your research questions first and wait for my OK. At the end, separate confident findings from uncertain ones.Note: Requiring dated, linked sources and an "uncertain" bucket is what keeps a research agent honest.
5. Automate a repetitive workflow
Goal: Turn my repetitive task into a reusable, one-command workflow.
Deliverable: A step-by-step automation plan plus the artifact that runs it (a script, template, or Sheet with formulas — you choose and justify).
Context: The task I do by hand every [FREQUENCY]: [DESCRIBE EACH STEP]. Inputs I start with: [PASTE]. Output I need: [DESCRIBE].
Constraints: Must work with the tools I have: [LIST TOOLS]. No paid services. Handle the common error case: [EDGE CASE].
Checkpoints: Show me the proposed workflow and where a human still needs to approve, then build. Return usage instructions.Note: Letting Kimi choose the artifact — but justify it — beats forcing a tool it can't use well.
6. Scrape and organize data
Goal: Collect and organize [WHAT DATA] from [SOURCE / LIST OF URLS].
Deliverable: A Sheet with one row per item and columns [FIELDS TO EXTRACT], sorted by [FIELD], with duplicates removed.
Context: Source(s): [PASTE URLS OR DESCRIBE]. What a good row looks like: [ONE EXAMPLE ROW].
Constraints: Only public data. If a field is missing, leave it blank rather than guessing. Note the source URL for each row.
Checkpoints: Pull the first 5 rows and show me before doing the rest, so I can confirm the fields are right.Note: The first-5-rows checkpoint catches a wrong field mapping before Kimi scrapes hundreds of them.
7. Turn a design / mock into code
Goal: Convert the attached design into working front-end code.
Deliverable: A responsive HTML/CSS build that matches the mock, plus a note on any spot where the design was ambiguous.
Context: Mock attached (image/screenshot). Breakpoints I care about: [MOBILE / TABLET / DESKTOP]. Fonts: [FONTS]. Interactive bits: [WHAT SHOULD CLICK/HOVER].
Constraints: Match spacing and color to the mock, semantic HTML, no framework unless you flag why.
Checkpoints: Point out any measurement or state the mock doesn't show and ask me before assuming. Deliver the code, then a screenshot of your render.Note: Kimi's multimodal input reads the mock directly — asking it to flag ambiguity prevents confident wrong pixels.
8. Multi-file coding task
Goal: Add [FEATURE] to my project without breaking existing behavior.
Deliverable: The full set of changed/new files, each complete, plus a short summary of what changed and why.
Context: Project attached / pasted. The feature should: [BEHAVIOR]. Relevant existing files: [LIST]. Tests I care about: [WHAT MUST STILL PASS].
Constraints: Match the existing code style, no new dependencies without flagging, keep functions small.
Checkpoints: Show me your implementation plan and the files you'll touch before writing code. After building, list what you changed and what you did not touch.Note: For heavier builds, pair this with the Kimi coding prompts and turn on Thinking for the plan step.
9. Plan-then-build a small app
Goal: Build a working [APP TYPE — e.g., habit tracker / quiz / expense splitter] I can use today.
Deliverable: A single-file web app (HTML/CSS/JS) with [CORE FEATURES], data saved in the browser, and a clean mobile layout.
Context: Who uses it: [USER]. The core job it does: [JOB]. Nice-to-haves if there's time: [LIST].
Constraints: Works offline, no backend, no external accounts. Keep it under [N] core features for v1.
Checkpoints: First propose the feature list and data model and wait for my OK. Build the core first, confirm it works, then add nice-to-haves.Note: Splitting "core first, then extras" at a checkpoint gets you something usable even if the agent runs long.
10. Agent-swarm orchestration
Goal: Produce a complete [DELIVERABLE — e.g., go-to-market kit] for [PRODUCT] using a swarm of specialized sub-agents.
Deliverable: A bundle — a research brief (Doc), a landing page (HTML), a pitch deck (Slides), and a launch checklist (Sheet) — that all reference the same positioning.
Context: Product: [PASTE]. Audience: [WHO]. Positioning we want: [ANGLE]. Brand: [COLOR/TONE]. Assets attached.
Constraints: Assign roles — one sub-agent researches, one writes copy, one builds the page, one builds the deck. Keep messaging consistent across all pieces.
Checkpoints: Have the researcher deliver the positioning first; I approve it before the others build on it. At the end, summarize what each sub-agent produced.Note: Gating the swarm on an approved positioning keeps every downstream artifact aligned instead of drifting apart.
Get the formula and the mode right and Kimi does the rest. Bookmark the Kimi prompt cheat sheet for the one-page version, and the best Kimi prompts roundup for the full library.
Frequently Asked Questions
What is Kimi Agent Mode (OK Computer)?
Agent Mode, branded OK Computer, is Kimi's autonomous mode. Instead of just replying, Kimi plans the task, then builds and runs the work across many coordinated steps and tool calls — creating Websites, Docs, Slides, and Sheets, and dispatching an Agent Swarm of specialized sub-agents. You give it a goal and the exact deliverable; it does the multi-step work and hands back the artifact.
When should I use Instant, Thinking, or Agent Mode in Kimi?
Use Instant for quick answers, lookups, and short rewrites. Use Thinking for hard reasoning, tricky code, or anything where you want Kimi to catch missing requirements and edge cases before it commits. Use Agent Mode (OK Computer) when the task has a concrete deliverable that takes many steps to build — a site, a deck, a tracker, a scrape-and-report — and you want Kimi to plan and execute autonomously.
What is the formula for a great Kimi agent prompt?
Goal → Deliverable → Context → Constraints → Checkpoints. State the outcome you want, name the exact artifact (a 10-slide deck, a live landing page, a tracker sheet), paste every input up front, list the hard rules the result must satisfy, and tell Kimi what to confirm or return at the end. Give all inputs before the agent starts so it isn't guessing halfway through.
Why does specifying the exact deliverable matter for agents?
An agent runs many steps unsupervised, so a vague target compounds. If you name the exact artifact and its acceptance criteria — file type, length, sections, what done looks like — Kimi has a fixed thing to build toward and to check its work against. Ask for a landing page and you get a guess; ask for a single responsive HTML landing page with a hero, three feature blocks, and a working email capture, and you get the thing.
What is the Agent Swarm in Kimi?
For larger tasks, Agent Mode can spin up an Agent Swarm — multiple specialized sub-agents that work in parallel and hand results back to a coordinator. One might research, one draft, one build, one check. You don't manage them directly; you describe the overall goal, the roles you want covered, and how the pieces should fit, and Kimi orchestrates the swarm.
Is Kimi free to use for agent tasks?
Yes, Kimi is free to start at kimi.com. It runs the Kimi K2.7 / K2 family — a trillion-parameter mixture-of-experts model with roughly 32B active parameters, a 256K context window, and multimodal input. Agent Mode, Thinking, web search, and file and image upload are available to try without cost, though heavier agent runs may have usage limits.
How do the [BRACKET] placeholders work?
Anything in square brackets is a swap-in. Replace [GOAL], [PASTE CONTENT], or [CONSTRAINTS] with your own details before sending. The rest of each prompt is written to be copy-paste ready.