Kimi K3 + Agent OS in Action: The Open-Source AI Agent That Can Run for Days

Hand a big task to an AI and walk away — not for five minutes, but for days. Most AI systems stop the moment you stop watching, but an Agent OS built on the open-source model Kimi K3 can keep running unattended. This article is based on a hands-on demo by a Bilibili creator (朱莲Goldie数字分身), breaking down how this setup achieves autonomous learning, trend tracking, article writing, and even 3D video generation.

Core Architecture: The Model Is Just a Swappable Slot

The design philosophy of the entire system is straightforward — one dashboard, one swappable "brain," and a pair of agents that do the actual work. The brain is the Kimi K3 model (developed by Moonshot AI), while execution is handled by an open-source agent called Hermes, which handles clicking, typing, and running tools.

Loading the model is lightweight: open a terminal to launch Hermes, select Moonshot from the model list, and log in. If you'd rather skip the command line, just type Kimi in the management panel and switch with two clicks. This "slot-based" design means you can run Kimi today and swap in a different model tomorrow — the rest of the setup stays untouched.

This is the fundamental difference between Agent OS and a simple chat box — the model is abstracted into a pluggable component, while the system itself provides stable workflows, a memory layer, and scheduling capabilities.

MCP (Model Context Protocol) is an open protocol released by Anthropic in late 2024, designed to standardize how large language models connect to external tools and data sources. Think of it as the "USB port" of the AI world — as long as a tool implements an MCP server, any MCP-compatible model client can call it directly, with no need to write custom adapter code for each tool. Blender, databases, web browsers, and more can all be exposed as callable "tool slots" via MCP. This is the underlying mechanism that allows Kimi K3 to directly control Blender for 3D modeling. Hermes, as an open-source agent framework, is essentially a runtime environment that parses model outputs, schedules tool calls, and manages the execution loop — translating the model's "intentions" into actual clicks, inputs, and program calls.

From "Learning" to "Trend Tracking": The Agent Starts Using Tools on Its Own

The real capability shows when the agent actively calls tools. Hermes has a Learn command: give it a guide link, and it will read the entire document, break down the content, and save it as a reusable "skill." This skill file is stored on your local machine, and you can open it to see what key points it extracted — essentially, teach it once and it remembers permanently.

Building on this, the demo showcases two noteworthy workflows:

Oracle: Monitor Trends and Auto-Draft Articles

Oracle uses Kimi as its brain to pull the latest topics from Twitter on a schedule, sorted by fastest-rising. It refreshes at a fixed time each day, so the trending list is ready when you wake up. Going further, one click on "publish" from the trend list prompts Kimi to write a complete article on that topic — with a clean title, formatting, and a small table — and publish it directly to a website.

Astros: Find Rankable Content Angles

Another workflow, Astros, monitors competitors and keywords, delivering a daily digest of "what's trending and how to create content around it that actually has a ranking opportunity" — complete with unique angles that can be fed directly to a video agent or turned into a report. It doesn't just observe; it puts the next step in your hands.

Long-Horizon "Goal Mode": Built for Multi-Day Runs

The "run for days" capability teased at the start comes from what the author calls "goal mode." Kimi K3 was designed from the ground up for long tasks — it has an ultra-long context of roughly 1 million tokens and can maintain coherent reasoning across extremely lengthy tasks.

The usage is straightforward: give it a goal, tell it to keep going until it's done, and it loops continuously. For example, ask it to plan and write a complete set of articles on a topic, and it can run autonomously for hours or even days. You can stop it after 30 minutes or let it keep going. This is the difference between "chat that waits for you" and "agents that work while you're away."

The system also supports an "agent hybrid mode" — running Kimi K3 alongside another open-source model (such as the GLM series) to collaborate on the same task and deliver a combined answer. The benefit is that you can achieve strong results with lighter open-source models without relying on big-name closed-source tools for everything.

Context Window is the core constraint that determines whether a large language model can handle long tasks. It represents the maximum amount of text the model can "see" in a single inference pass — including conversation history, tool call records, intermediate results, and everything else. Early mainstream models had context windows of roughly 4K–32K tokens (approximately 3,000–24,000 Chinese characters), often "forgetting" early information midway through long documents or multi-step tasks. The Kimi series is known for its ultra-long context; commercial versions support up to 128K tokens or more, while K3 is described by the demo creator as reaching approximately 1 million tokens. This means the agent can retain all previous intermediate steps, completed modules, and pending items in its "working memory" throughout a continuous multi-day work loop — rather than losing context every so often and being forced to start over. This is the technical prerequisite that makes "goal mode" possible.

Why Kimi K3 Excels at Frontend and Visual Content

The demo creator emphasizes that Kimi K3 topped a benchmark called the "Frontend Code Arena" — an evaluation where real developers blindly vote on which model produces the better UI. According to the creator, Kimi K3 ranks first on that leaderboard, winning 6 out of 7 categories, with only the gaming category as a slight miss.

To be objective: the author also acknowledges that overall, Kimi is still slightly behind the very top models. But for building clean, attractive frontends specifically, it's currently the benchmark — and its open-source nature is what's driving the widespread attention.

This capability extends into two standout applications:

• MCP + Blender for 3D modeling: By connecting Kimi K3 to the free 3D tool Blender via MCP, you can hand it a product and it will complete 3D modeling and generate a promotional video. The creator calls it an "imagination printer."
• Remotion for code-generated video: Remotion is an open-source tool for generating video with code. The promo video Kimi produced was an interactive website video that tracks mouse movement — complete with a progress bar, clickable navigation, zoom effects, and color theming, all written and integrated by the agent.

There's also an underrated use case: set up a Kanban board and have multiple Kimi agents play the roles of director, QA, and builder, passing tasks between cards until completion.

Memory Layer: Giving Everything a Shared Knowledge Base

A standalone model is just a chat box. Agent OS turns it into a "worker." The system uses Obsidian (a free note-taking app) as its memory layer, saving everything the agents learn.

Oracle, Astros, goal mode, and the Kanban board all live in the same place, sharing the same memory. This is the dividing line between "playing with AI" and "actually putting it to work."

The author also addresses a common concern head-on: many people hear "open-source agent" and are immediately put off, assuming it's clunky, requires too much back-and-forth, and can't match the smoothness of big-name tools. That was a reasonable concern in the past — but once a model like Kimi K3 is plugged in, the experience becomes fluid and practical. What remains is a fully self-owned setup that can run entirely on open-source models at no cost.

Obsidian is a free knowledge management tool based on local Markdown files. Its core feature is that all notes are stored as plain text on the user's own hard drive, not on a cloud server. This makes it an ideal foundation for the Agent OS memory layer: skill files the agents have learned, scraped trend summaries, and completed task contexts all land on disk as readable, searchable text files — with no dependency on external service availability, and easy for users to inspect and edit directly. By contrast, cloud API-based memory solutions carry data sovereignty and service interruption risks. Using Obsidian as a shared knowledge base allows multiple parallel workflows (Oracle, Astros, Kanban agents) to read and write the same files, enabling cross-workflow knowledge accumulation — a key design choice that upgrades one-off task execution into a continuously learning system.

Takeaway: The Inflection Point for Practical Open-Source Agents

The value of this demo isn't any single feature — it's the "model + operating system + memory layer" paradigm it demonstrates: the model handles reasoning, Agent OS handles scheduling and persistence, and the memory layer accumulates experience. For anyone looking to genuinely use AI for content production rather than staying at the demo stage, this is a practical blueprint worth considering.

A note of caution: this article is based on a demo from a single source, and some benchmark data (such as the "Frontend Code Arena" rankings) has not been independently verified. Real-world deployment may still encounter engineering issues such as model loading errors and workflow failures. Readers are encouraged to test and evaluate for themselves.