Grok Bot + Kimi K3. Here’s how to build an AI team that generates $100k/month.

xAI just showed the world what the next software category looks like. Not another chatbot. Not another copilot. An AI that has a computer, uses tools, takes actions and works autonomously while you sleep.

They called it Grok Bot.

And right now you can build your own version. Not a demo. Not a prototype. A real AI employee that handles a specific job inside a real business - with memory, tools, approval gates and the ability to run 24 hours a day without asking you what to do next.

You don't need xAI's budget. You don't need a team of researchers. You need Kimi K3, the Agent SDK and four hours on a Saturday.

Here's the exact system.

my sources: linktr.ee/Noisy7

What Grok Bot actually showed

Most people saw the announcement and thought "cool AI assistant." That's the wrong frame.

Grok Bot showed a new category of software. Not a tool you hold. A worker you delegate to.

Old software category:
Tool → you use it → output

New software category:
AI Employee → you delegate → it works → output

The difference is autonomy. Grok Bot has a computer. It uses tools. It makes decisions. It takes actions. It reports back when done or when it needs approval.

This is not a smarter autocomplete. This is a job that runs without a human in the loop for every step.

And here is the most important thing about this announcement for builders: xAI spent hundreds of millions building the infrastructure to make this possible. Moonshot already exposed most of the primitives you need to build your own vertical version. For a fraction of the cost. Available right now.

Why Kimi K3 is the right foundation

> github.com/MoonshotAI/Kimi-K3

Kimi K3 is not interesting because it has 2.8 trillion parameters. It's interesting because Moonshot built the entire execution infrastructure around it.

Kimi K3 alone:
Brain
↓
answers questions

Kimi K3 + full stack:
Brain
+
Hands (Kimi Code)
+
Memory (Skills + Graph)
+
Tools (MCP)
+
Workers (AgentSwarm)
+
Control (Approvals)
↓
AI Employee

Most models give you the brain and nothing else. You figure out the rest. Kimi gives you the full stack. That's what makes it possible to build something that actually works in production without a team of engineers.

Layer 1 - Kimi Code: the execution engine

> github.com/MoonshotAI/kimi-code

This is what separates an AI that talks from an AI that works.

Kimi Code gives K3 hands. It can read and edit files across a codebase, run shell commands, search for information, fetch web pages, analyze results and independently choose the next action based on what it finds. It supports MCP, lifecycle hooks, subagents and Skills.

Without Kimi Code:
K3 describes what should happen

With Kimi Code:
K3 does what should happen

A real example. You tell the AI employee to research a potential client. Without Kimi Code it writes you a list of things to look up. With Kimi Code it opens their website, reads their LinkedIn, searches their funding history, pulls their job postings as a signal of growth, checks if they're a customer of your competitors and writes a structured briefing into your CRM. You come back to a finished output.

That's the difference between a tool and an employee.

Layer 2 - Kimi Agent SDK: turn it into software

> github.com/MoonshotAI/kimi-agent-sdk

Kimi Code is for interactive sessions. The Agent SDK is for building products on top of the runtime.

Available in Python, Node.js and Go. It reuses the same tools, Skills and MCP configurations from Kimi Code. Which means everything you set up interactively - your workflows, your Skills, your tool connections - is immediately available programmatically.

from kimi_agent_sdk import Agent, Session

# Create a persistent AI employee session
session = Session(
    work_dir="./client-research",
    skills=["sales-research", "crm-update"],
    mcp_servers=["crm", "linkedin", "email"]
)

agent = Agent(session=session)

# Delegate a complete job
result = agent.run(
    task="Research Acme Corp and prepare a sales briefing. 
          Check their recent news, LinkedIn, job postings 
          and update our CRM with findings.",
    require_approval=["send_email", "update_deal_value"]
)

This is not calling an API and getting text back. This is delegating a job to a software system that runs it end to end and returns a structured result.

What you can build with this:

Bug fixing bot         |  watches issues, fixes automatically
Code review service    |  reviews every PR before human sees it
Sales research agent   |  prepares briefings before every call
Client onboarding      |  runs onboarding workflows automatically
Internal knowledge     |  answers questions about your company
Reporting agent        |  generates weekly reports without prompting

Layer 3 - Skills: encoding the job

> kimi.com/code/docs/en/kimi-code-cli/customization/skills.html

This is the Grok Bot "Teach a Task" equivalent. And it's the layer that turns a generic AI into a specialist.

A Skill is a markdown file that encodes how a specific job should be done. Rules, workflow, constraints, what to never do. Kimi reads it automatically when the task matches and follows it without being told.

Real example for a sales AI employee:

---
name: sales-research
description: Research a company before a sales call
whenToUse: When preparing for a sales meeting or follow-up
---

# Sales Research Skill

## Step 1 - Company overview
Find their website, LinkedIn, recent news last 90 days.
Check funding history and current headcount.

## Step 2 - Pain signal detection
Read their job postings - what they're hiring reveals priorities.
Check their G2 or Capterra reviews for competitor complaints.
Look for recent leadership changes.

## Step 3 - Opportunity mapping
Map their pain points to our product capabilities.
Identify the economic buyer vs the champion.
Note any risks or red flags.

## Step 4 - CRM update
Update the company record with findings.
Add a call prep note with the three most important talking points.
Log your research sources.

## Rules
Never make up information you couldn't find.
Never contact the prospect directly.
Flag if deal size looks above €50,000 for manager review.

After writing this once:

You ask: "Research Acme Corp before tomorrow's call"
↓
Kimi activates sales-research skill automatically
↓
Follows your exact process every time
↓
Updates CRM without being told
↓
You walk into the call already briefed

The compounding effect is significant. Every job you encode in a Skill runs consistently forever without re-explaining. Every mistake you catch becomes a rule that prevents the next occurrence.

You don't train a new model every time you hire an AI employee.
You encode the job into a Skill.

Layer 4 - Agents and AgentSwarm: divide the work

> kimi.com/code/docs/en/kimi-code-cli/customization/agents

One AI employee is powerful. A coordinated team of specialized agents is a department.

Kimi Code has a main agent that understands intent, plans steps, calls tools and delegates subtasks to subagents. Each subagent runs in its own isolated context so intermediate work doesn't fill up the main agent's context window.

Built-in roles: coder writes and executes, explore researches codebases, plan handles complex decomposition.

Custom agents let you build:

                    KIMI K3
                       │
                  MAIN AGENT
                       │
       ┌───────────────┼───────────────┐
       ▼               ▼               ▼
  SALES AGENT    RESEARCH AGENT    DEV AGENT
       │               │               │
       ▼               ▼               ▼
      CRM             Web            GitHub
     Email            Docs           Terminal

AgentSwarm takes this further. Up to 128 subagents working in parallel on different items from the same task.

Research 100 companies
↓
WITHOUT SWARM:
One agent → sequential → hours

WITH SWARM:
AgentSwarm
↓
Company 1 → Agent
Company 2 → Agent
Company 3 → Agent
...
Company 100 → Agent
↓
Parallel execution
↓
Aggregated report
↓
Kimi synthesizes

The important caveat: more agents doesn't automatically mean better results. Coordination quality matters more than agent count. Decompose by role not by scale.

Layer 5 - MCP: connect the employee to the company

A client doesn't pay €500 per month for a smart chat. They pay for a system that reads their CRM, drafts proposals, updates tickets and follows their actual workflow.

MCP is what makes the AI employee part of the company's infrastructure rather than a tool sitting next to it.

Kimi K3
↓
MCP
↓
GitHub    |  reads repos, opens PRs, comments on issues
CRM       |  reads pipeline, updates records, creates tasks
Database  |  queries live business data directly
Email     |  drafts and sends with approval
Slack     |  posts updates, pings humans on escalations
Browser   |  researches competitors, pulls public data

In agent definitions you can explicitly allow specific MCP tools:

agent_config = {
    "name": "sales-employee",
    "allowed_tools": [
        "mcp__crm__*",        # full CRM access
        "mcp__email__draft",   # can draft but not send
        "mcp__browser__*",     # full web access
        "mcp__slack__read"     # read only, no posting
    ]
}

Every tool the agent can access is a capability you're selling. Every restriction is a trust boundary you're building.

Layer 6 - Approvals: keeping humans in control

This is the layer that makes AI employees production-safe rather than production-scary.

Kimi Code has permission rules that determine what the agent can do automatically versus what requires human approval:

READ operations
→ automatic
→ research, analyze, read database, read emails

WRITE with rules
→ conditional
→ update CRM if confidence above threshold
→ create ticket if priority is clear
→ edit document if changes are minor

HIGH STAKES
→ human approval required
→ send contract
→ deploy to production
→ delete records
→ make purchases above limit
→ contact client directly

A real permission configuration:

{
  "permissions": {
    "allow": [
      "Read",
      "Grep",
      "mcp__crm__read_*",
      "mcp__browser__*"
    ],
    "deny": [
      "mcp__email__send",
      "mcp__crm__delete_*"
    ],
    "ask": [
      "mcp__crm__update_deal_value",
      "mcp__email__draft"
    ]
  }
}

This architecture means the AI employee can run autonomously on research, analysis and drafting - and pause for human judgment on anything irreversible.

That's not a limitation. That's a feature you sell to enterprise clients who need AI assistance without AI risk.

The business you can build on this

The opportunity is not selling access to Kimi. It's packaging Kimi into a worker that understands one expensive job better than a generic AI ever will.

Real estate agency AI employee. Researches properties, prepares client briefings, drafts proposals, follows up on leads, updates the CRM after every interaction. Price: €499-€999 per month per agency.

Law firm research assistant. Reviews case precedents, summarizes documents, flags relevant clauses, prepares briefings for lawyers. Price: €1,500-€3,000 per month per firm.

E-commerce operations agent. Monitors inventory, updates product descriptions, responds to supplier emails, flags anomalies in sales data. Price: €299-€599 per month per store.

The math on any of these:

Real estate AI employee:
50 agency clients × €499/month = €24,950/month
Infrastructure cost: ~€500/month
Margin: ~98%

Law firm assistant:
20 firm clients × €1,500/month = €30,000/month
Infrastructure cost: ~€800/month
Margin: ~97%

You're not building a general AI product. You're building a specialist. The Skill files encode the expertise. The MCP connections encode the workflow. The approval rules encode the trust boundaries. That combination is what competitors can't easily copy.

How to build your first AI employee this week

Day 1 - pick one expensive job that a business pays humans to do. Sales research. Contract review. Customer onboarding. Inventory management. The job should be repetitive, research-heavy and have clear output.

Day 2 - install Kimi Code and run the job manually with the agent. Watch what it does. Where does it get stuck. What information does it need. What actions does it take.

Day 3 - write the Skill file. Encode every step you observed into a SKILL.md. Add the rules, the constraints, the approval requirements. Test it on five real examples.

Day 4 - connect MCP to the tools the job actually needs. CRM, email, database, browser. Test each connection. Verify the agent uses them correctly.

Day 5 - build the Agent SDK wrapper. Turn the interactive session into a programmable product. Add the approval gates. Test the full workflow end to end.

Day 6 - find one real client. Show them the agent doing their actual job on their actual data. Not a demo. Their real workflow.

Day 7 - charge for it.

What this actually means

Grok Bot showed that AI employees are the next software category. Not chatbots with more features. Workers with actual autonomy, tools and memory.

The companies that win this category won't be the ones with the most parameters. They'll be the ones that encode the most domain expertise into Skills, connect the most relevant tools through MCP and build the most appropriate approval structures for their clients.

Kimi K3 gives you the intelligence. Kimi Code gives it hands. The Agent SDK turns it into software. Skills encode the job. MCP connects it to the company. AgentSwarm scales the work. Approvals keep humans in control.

Grok Bot spent hundreds of millions building that stack. You can start building yours this Saturday.

Most developers will look at Grok Bot and think "I could never build that." A few will look at Kimi's documentation and realize they already have everything they need.

You build your own life - so choose the right path.

/ If this was useful - follow /