# Did the gold price crash leave you stunned? I used Kimi K2.5 + Cherry Studio to build a “replay神器” (with Agent design + complete tutorial)
Recently, gold suddenly plunged, and many people’s first reaction was: should we run? Should we buy the dip?\
But looking back, gold is the kind of asset that is best at “putting pressure on the market.” Its violent swings often carry echoes of history:
* **A sudden shift in macro expectations**(interest rates / inflation / a stronger dollar), and gold is prone to a quick pullback
* **When risk events heat up**(conflicts, financial system stress), safe-haven demand pushes prices up again
* **When liquidity is tight**it can even show the counterintuitive pattern of “fall first, then rise”
The problem is: scrolling through ten news items gives you emotions; what you need is**a chain of evidence**.\
Coincidentally, Moonshot recently released and open-sourced **Kimi K2.5** —the most intelligent and versatile open-source model Kimi has had to date, reaching open-source SOTA on **Agent, code, image/video** and other tasks.
\
**So I came up with a bold idea:** Since the human brain can’t process so much messy information all at once,**could we let Kimi K2.5 live inside the Agent in Cherry Studio and help me dig into this “gold crash” from top to bottom?**
This article is not a dull manual, but a guide to using the latest model and the most hardcore Agent skills to equip yourself with a 24/7 financial analysis team. At the end, I’ll provide the folder for this Agent `Kimi Agent`.
After you download it and spend 3 minutes configuring it, you can run it. Below, I’ll break down the design logic, folder structure, component breakdown, and execution flow. If you’re staring at candlestick charts wondering whether to buy the dip, or bombarded by news but unable to find the real cause, you need this.
## **Why design it this way? (3 hard-core reasons, no detours)**
1. **Data authenticity comes first, zero tolerance for fabrication**: Financial analysis fears “AI hallucinations” the most. So every step is forced to include a source + timestamp; if it can’t be found, it throws an error (no guessing). Public sources (such as Kitco and Investing.com) ensure there is zero API key barrier.
2. **Task modularization + parallelism**: The highlight of Kimi K2.5 is its “Agent cluster” (self-splitting, parallel 1500 steps). We simulate this with Cherry Studio’s Skills + Sub-agents: data fetching, news collection, and report generation run in parallel, doubling efficiency.
3. **Modernized output**: No Markdown output (who still reads plain text?), but direct HTML generation (Chart.js charts + responsive layout), benchmarked against Kimi K2.5’s code generation capabilities.
Result: one report = nearly one year of price trends + crash timeline + three-scenario forecast + full source links. Send it to the boss or the group chat, and it’s ready to use immediately.
### **📁 Folder structure: Why is it compatible with Claude Code?**
The core is the `.claude/` directory — Cherry Studio recognizes this and can automatically load Skills and configuration. The complete structure comes from your `06-DIRECTORY_STRUCTURE.md`:
```python
Kimi Agent/ # Project root
├── .claude/ # Cherry Studio Agent core configuration area
│ ├── prompts/ # System prompts (bilingual)
│ │ ├── system_prompt_cn.md # Chinese version: defines Agent behavior + data authenticity rules
│ │ └── system_prompt_en.md # English version
│ ├── skills/ # 3 core Skills (auto-recognized)
│ │ ├── skill_financial_data_fetcher.md # Data fetching + verification
│ │ ├── skill_geopolitical_analyst.md # Event analysis + timeline
│ │ └── skill_financial_report_generator.md # HTML report generation
│ ├── agents/ # Sub-agents configuration
│ │ ├── subagent_financial_intelligence.md # Quantitative analysis submodule
│ │ └── subagents_usage_strategy.md # Collaboration strategy
│ ├── config/ # Path/tool configuration
│ │ └── paths.conf
│ ├── settings.json # Main config: model + prompt paths + tool list
│ └── mcp.json # MCP (tool server) configuration
├── docs/ # Documentation backup (README, data sources, changelog)
├── start-gold-agent.sh # One-click startup script (optional)
├── USER_PROMPT_EXAMPLE.md # Example instruction
└── Backup directory (core_config/ skills/ etc.) # Original file backups, not used at runtime
```
**Why split it up this way?**
* `.claude/` This is Cherry Studio’s standard recognition path: select the working directory, and it automatically loads the Skills (filename `skill_*.md` → Skill name `financial-data-fetcher`).
* The backup area prevents loss: the original Skills are in the root skills/ directory, and at runtime they are used via `.claude/skills/`.
### **🔧 Core component breakdown: 3 Skills + plugins + Sub-agents**
#### **🧩 Details of the three core Skills**
Let’s take a look at how these three “avatars” are specifically designed, and why they are designed this way.
**Skill A:`financial-data-fetcher` (data hunter) — rejects hallucinations**
* **Design pain point**: General-purpose LLMs are most likely to “make up” prices. You ask about gold prices, and it might invent 2023 data for you.
* **Skill logic**:
* **Hard constraint**: We hard-code the rule in the Prompt —*“It is forbidden to use prices from training data; tools must be called”*.
* **Toolchain**: Equipped with `WebFetch`. It doesn’t “search” Baidu; it directly “crawls” specified data source pages (such as Kitco, GoldPrice.org, LBMA).
* **Data cleaning**: It cleans the messy HTML it crawls into a clean `JSON` format (timestamp, open, close, change).
* **The role of Kimi K2.5**: Using its powerful**long-document extraction capability**, it can precisely locate the `$2,xxx.xx` number among tens of thousands of lines of webpage code.
**Skill B:`geopolitical-analyst` (geopolitical logic library) — rejects noise**
* **Design pain point**: There are many reasons for a gold crash (dollar up? war? selling pressure?). A normal search will also pull in fake news from clickbait accounts.
* **Skill logic**:
* **Cross-source verification**: It doesn’t just search for “gold price,” but also searches in parallel for “Dollar Index (DXY),” “Fed minutes,” and “geopolitical situation.”
* **Time alignment**: It executes a core logic —**“TimeStamp Matching”**.
* *Finds that:* Gold plunged at UTC 14:30.
* *Search:* What happened at UTC 14:30?
* *Match:* It finds that the U.S. released CPI data at UTC 14:30 that exceeded expectations.
* *Conclusion:* The plunge was triggered by inflation data.
* **The role of Kimi K2.5**: Using its **Agent cluster (avatar) capability**, it can simulate “reading 20 news articles at the same time” and filter out emotional noise, keeping only facts.
**Skill C:`financial-report-generator` (front-end engineer) — rejects mediocrity**
* **Design pain point**: This is also one of Cherry Studio’s most impressive steps. Most Agents only spit out a paragraph of Markdown, and even tables are crooked and messy.
* **Skill logic**:
* **Code first**: This Skill is trained to “speak only in code.” It doesn’t write articles; it writes HTML + CSS + JavaScript.
* **Dynamic interaction**: Even if you have no programming background, this component will call the `Chart.js` library to turn the data fetched by Component A into a zoomable, hoverable candlestick chart.
* **Visual integration**: It embeds Component B’s analytical conclusions into the webpage layout in the form of “cards” or a “timeline.”
* **The role of Kimi K2.5**: Using its upgraded **Code (programming)** capability, especially front-end construction ability. The code generated by Kimi K2.5 is extremely robust and can almost run in a browser without manual debugging.
\
#### **What is the role of Sub-agents in this Agent setup? 🧩**
Next, let’s clearly explain the “Sub-agent” layer inside **Kimi Agent (gold market analysis Agent)** : what they are, why they’re used, how they collaborate, and what you can see in the folder.
> *First, let’s make this clear:* ***Skills** are more like “reusable process modules”;**Sub-agent** is more like a “dedicated role with its own work instruction manual.”*
\
The main Agent (the `Gold Market Analysis Agent`you create in Cherry Studio) is responsible for three things:
1. **Task decomposition**: breaking “analyze gold trends / review crashes / write reports” into several independent subtasks
2. **Task dispatch**: assigning subtasks to different Sub-agents (each with clear boundaries and output format)
3. **Acceptance and summarization**: checking whether the data has sources and timestamps, and whether there are gaps; then handing it to the report generation module to produce HTML
Why not let one Agent do everything?
* Because the requirements for context and tool usage differ for “fetching data, reading news, calculating indicators, and writing front-end reports,” and combining them into one Prompt is most likely to go off track.
* After splitting them up, each sub-agent’s rules can be written much more strictly:**which tools are allowed, what structure to output, and how to handle failures**.
\
**What Sub-agents are in this configuration? What does each do? ✅**There are mainly three types of Sub-agents in this package (two system presets, one custom):
**A. System preset:`search-specialist`(search and information organization)**
* **name**: `search-specialist`
* **Responsibilities**: advanced search, result filtering, cross-source verification, citation organization
* **Output characteristics**: provides search strategies, source URLs, and key citations (suitable for building a “crash trigger timeline”)
When used for gold analysis, it is usually responsible for:
* the news source, publication time, and key sentences related to the “crash”
* official/authoritative source pages corresponding to central bank and macro data releases (such as CPI and rate decisions)
* multi-source validation of the same indicator (for example, Kitco vs GoldPrice vs Investing)
**B. System preset:`business-analyst`(metrics and correlation analysis)**
Its tools are `Read, Write, Bash`, and it is very suitable for**structured analysis**:
* correlations (gold vs DXY, gold vs real interest rates)
* ETF holdings changes (such as SPDR Gold Trust)
* KPI calculations (annualized volatility, drawdown, etc. — provided real data has been obtained)
Its value lies in:**turning descriptions that “look like analysis” into conclusions that are “computable and have intermediate steps.”**
**C. Custom Sub-agent:`financial-intelligence-agent`(historical data / technical indicators / forecasting)**
Path:`.claude/agents/subagent_financial_intelligence.md`It covers work that is more of a “quantitative pipeline”:
* pulling historical data (OHLCV, economic indicators, interest rates, inflation, etc.)
* calculating RSI / MACD / Bollinger Bands / moving averages / volatility
* outputting a set of traceable intermediate files: CSV, JSON (for example `gold_technical_indicators.csv`,`correlation_analysis.json`,`gold_price_forecast_12m.csv`)
> *This layer is especially important: it separates “technical analysis” from chat content and turns it into a storable deliverable. After that, reuse, comparison, and sharing with others all become easier.*
#### **How are Sub-agents “scheduled”? (parallel strategy) ⚙️**
This system prefers **parallelism**, because gold post-mortem analysis is naturally a multi-source information task.
**Phase 1: Parallel collection (reduce waiting)**
* `search-specialist`: search for key news/data release timeline on the day of the crash
* `financial-intelligence-agent`: pull the past year’s price series + calculate indicators
* `business-analyst`: calculate correlations and organize explanatory frameworks for ETF/macro factors
**Phase 2: Serial computation (dependencies go later)**
* Only after the historical data is written to disk are indicators / volatility / support and resistance calculated
* If data gaps are found, go back to `search-specialist` fill in the sources
**Phase 3: Summarize and deliver**
* The main Agent aligns the three result streams by timestamp and by methodology
* Then it calls the report generation module to output HTML (including charts, timeline, and citation list)
This is why this Agent performs better in “hot topic” scenarios: **gold crash = information-dense + inconsistent terminology**, and parallel evidence gathering + validation + summarization can significantly reduce the feeling of “I read a lot but am even more confused.”
***
#### **The relationship between Sub-agents and Skills: don’t mix them up 🤝**
In your package, the two are complementary:
* **Sub-agent**: more like a “specialized work mode,” solving the problems of “who does it, how to do it, what tools to use, and what format to output”
* **Skills (.claude/skills/)**: more like “reusable process modules,” solving the problem of “how to execute this step stably” For example:
* `financial-data-fetcher`: emphasizes multi-source verification, forbids inventing numbers, and outputs structured data
* `geopolitical-analyst`: emphasizes event classification, causal mechanisms, and timeline format
* `financial-report-generator`: emphasizes HTML templates, Chart.js, source lists, and printable styles
In short: **Sub-agents are responsible for distributing the work; Skills are responsible for making each step more stable and reusable.**
#### **How do you confirm in the folder that the Sub-agent is “really working”? 🔍**
Just check two places:
1. **whether the directory structure is standard**
1. `.claude/agents/` contains `subagent_financial_intelligence.md`
2. **run logs**(inside Cherry Studio)
1. you’ll see traces of tool calls and task dispatch (WebSearch/WebFetch/Bash/Write)
2. it can ultimately generate files on disk: for example `gold_analysis_report.html`, and if the configuration includes intermediate artifacts, CSV/JSON will also be output
If you want it to be “more obvious,” you can add a hard constraint in the main Prompt:
> *“Please list in the report appendix which sub-agents / skills were called this time, and the filenames each produced.”*
That way readers can tell at a glance: this is not a chat, this is a pipeline.
## **🛠️ Hands-on tutorial: Recreate your own Agent in three steps**
No coding required, no environment setup required. I’ve packaged a**“Kimi Agent” folder**, and all you need to know is how to copy and paste.
### **Step 1: Model configuration (Moonshot’s `kimi-K2.5` + Anthropic endpoint)**
This is the core of making the AI smarter.
1. Open Cherry Studio → **Model Services** → click **Moonshot**
2. to jump to the Moonshot open platform and obtain **an API Key**(required for model calls; data fetching does not require an extra key)
**⚠️ High-energy warning (must do):** In Cherry Studio’s settings, set **“Endpoint Type”** to `Anthropic`.
* *Why change it?* Because Cherry Studio’s Agent protocol needs to run in Anthropic endpoint mode, so that Kimi K2.5 can perfectly orchestrate the Skills mentioned above.
\
### **Step 2: Create the Agent (mount the folder directly `Kimi Agent`)**
> At the end I’ve prepared for you a folder named `Kimi Agent` inside which all skills are preinstalled, so you don’t need to manually rewrite the Skills/Sub-agent.
1. In Cherry Studio, click next to the assistant list **+** → **Create Agent**
2. Name:`Gold Market Analysis Agent`(or whatever name you like).
3. Model: choose the newly configured **Moonshot /** `kimi-K2.5`
4. Working directory: choose the folder you downloaded and unzipped `Kimi Agent` Open the system prompt file in the folder (for example
5. .claude/prompts/system\_prompt\_cn.md `), and paste it into Cherry Studio’s`system prompt **box.**Step 3: Enable tool permissions + plugins + Skills (check everything that applies)
### **Enable permissions**
1. **: In the Agent settings, enable permissions and authorize the tools (missing even one may cause it to get stuck):**bash
* `fetch`
* `edit`
* `multiedit`
* `webfetch`
* `web search`
* `write`
* `write`
2. **Configure plugins:**
Add system preset plugin:
* `business-analyst`
* `search-specialist`
System skills:
* `Excel Analysis`
## **witness the “magic”**
Everything is ready. Open the `USER_PROMPT_EXAMPLE.md`in the folder, which contains a ready-made**deep instruction**—copy it directly and send it to the Agent.**This instruction will make the Agent do three things:**
1. **Check**: search for the specific drop percentage and time of the gold crash.
2. **Find**: use Kimi K2.5’s online access to find Moonshot’s official introduction to the new model’s features (no fabrication allowed).
3. **Compare**: look for similar crash patterns in history and analyze whether there is an “echo” relationship.
### **📊 Final result: what did it deliver?**
Click send, and you’ll see the Agent start running wildly. The logs will show:`Thinking...` -> `Searching News...` -> `Calculating...`After a while, you won’t get a useless sentence, but a **deep research report in HTML format**:
* 📈 **Visualized gold trend over the past year**(charts + tables)
* 🧷 **marked key surge/drop intervals**(especially the “drop”)
* 🗓️ **event timeline**(each event includes a source link and can be verified)
* 📊 **technical indicator / correlation analysis**(calculated if data exists; clearly stated if missing)
* 🔮 **three-scenario forecast**(conditions, ranges, and risk warnings are clearly written)
* 🧾 **data source list**(URL + crawl timestamp)
\
**In the end, you will get a** `gold_analysis.html` **file that you can open and view directly:**
***
## **💭 Final thoughts**
What shocked me most this time was not how much stronger Kimi K2.5 has become, nor how easy Cherry Studio is to use. It was **“determinism”**. In financial markets, information is money.
In the past we guessed; now we rely on Agents. By putting Kimi K2.5 into Cherry Studio, we are essentially hiring ourselves a**“absolutely rational, connected 24/7, data-traceable”**super employee.
**You may not have avoided this gold crash, but if you learn this Agent workflow, at least in terms of understanding, you’ve already earned it back.**\
\
When you master**“breaking complex tasks down into Skills components”**this core logic, plus **Kimi K2.5** the qualitative leap in task planning and tool calling, you’ll find that the things you once thought “AI can’t do” can now all be handed over to Agents:
* **🕵️♂️ Market scout**: Don’t want to manually browse competitors’ pages? Let the Agent automatically fetch the latest prices and feature updates from 10 competitors, clean and deduplicate the data, and push a neatly organized Excel comparison table to your desktop every morning at 9 a.m.
* **💻 Shadow programmer**: Can’t finish writing code? It’s not just code completion—you can let the Agent read the entire project folder, automatically write feature modules based on requirements, run local tests, fix bugs, and conveniently generate a perfect API document.
* **✈️ Ultimate traveler**: Reject formulaic travel guides. Let the Agent compare flights and hotels in real time according to your budget, factor in weather and local event reviews, plan an itinerary down to the minute, and even generate a PDF roadbook.
\
**The real charm of Agents is not how long they can chat with you, but their autonomy and delivery capability**—they can, like today’s gold analyst, quietly get the work done while you’re drinking coffee. Once you experience this**“task automation”**feeling, you’ll never go back.
We sincerely invite you to break out of the framework and explore more hardcore, interesting, and practical scenarios. Whether it’s workflow optimization or everyday tech hacks, please share your creative ideas and Agent configuration files.
📩 **Submissions and communication**:\
**Don’t wait for the future. Your AI Agent era begins right now.**
\
👇 **Download now, connect Kimi K2.5, and build your first digital team:**
📥 **Appendix: Kimi Agent configuration folder download link:***(Please make sure Cherry Studio v1.7.0+ is installed)*
\
\
\
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.cherry-ai.com/docs/en-us/advanced-basic/agent-an-li/jin-jia-bao-die-kan-meng-le-wo-yong-kimi-k2.5-+-cherry-studio-zuo-le-ge-fu-pan-shen-qi-fu-agent-she.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.