Author: fkyah3 Project: experiment-console / Yishan ("Moving the Mountain") Tech stack: Godot 4.6 + GDScript GitHub: https://github.com/fkyah3/experiment-console Positioning: a message-building-block experiment bench for the DeepSeek API
The core problem
Calling a large-model API is a black box: you send a prompt, it returns text. What happens in between? How does the system message influence output? What is the relationship between reasoning_content and content? Why does the model's thinking language drift after tool calling?
Yishan's core idea is to break the API call into building blocks you can control, observe, and experiment with individually. More ambitiously, it proposes a philosophical design: the AI's body (model weights) lives in a data center; its soul (memory, thought anchoring, tool configuration) lives on your machine.
Methodological innovations
1. Message blockification
A traditional API call sends the whole messages array in one shot. Yishan splits it into independently operable blocks:
- Add/remove/edit system / user / assistant / tool messages one by one
- Independent control of
reasoning_content(not merged into content) - Per-message parameter tuning
- tool_calls detection is based on data presence, not finish_reason — because DeepSeek SSE does not send finish_reason
- Non-blocking reception, no UI freezes
- Real-time display of streamed content
- Tech stack: Godot 4.6 + GDScript, zero third-party dependencies
- Experiment scale: 320+ batch validations
- Analysis reports: 4 in-depth technical analyses
- Supported features: SSE streaming, tool calling, reasoning separation, batch experiments
- Platform: Windows, no installation needed (single exe)
- API support: DeepSeek API (extensible)
- RAG: giving the model external knowledge
- Yishan: giving the model an external "personality" — your memories, preferences, thought patterns
- Game engines natively support state management, scene switching, and resource loading — a natural fit for "memory scenes"
- Lightweight, cross-platform, visual
- Highly extensible (voice, 3D interaction in the future)
- GitHub: https://github.com/fkyah3/experiment-console
- Releases: https://github.com/fkyah3/experiment-console/releases/tag/v1.0.0
- Lanzou Cloud download: https://wwbst.lanzoul.com/ieYsh3p4u0cf
- DeepSeek-V3 Issue #1255 — Chinese vs. English reasoning control experiments
This is not a simple GUI wrapper but explicit management of conversation state — turning context that is implicitly buried in API calls into directly manipulable objects.
2. Full parameter visualization
Model selection, thinking toggle, effort level, max_tokens, temperature, top_p, frequency penalty — all graphically controlled. Combined with raw JSON logs (full request body + response body + usage stats), experiments are reproducible.
3. Self-implemented SSE streaming
SSE parsing is written from scratch on Godot's HTTPClient, zero third-party dependencies. Key details:
4. Batch experiment mode
Run N rounds with one click and auto-generate statistical reports. The project has accumulated 320+ batch validation runs and produced multiple analysis reports:
| Analysis report | Finding | |---|---| | Tracing reasoning-language drift after tool calls | root cause of reasoning switching from Chinese to English after tool calling | | Traditional-Chinese character leakage analysis | simplified-to-traditional character leakage caused by training data | | Reproduction analysis of reasoning-language drift | drift reproduced from a real "crime scene", confirming API-level behavioral differences |
These are not academic hypotheses but empirical data from 320+ real API calls.
Key numbers
Impact assessment
Short term: an API debugging bench
Yishan's current core value is as a DeepSeek API experiment bench, addressing practical pain points:
1. Reasoning-language drift: why does the AI start thinking in English after a tool call? Yishan located an API-level behavioral difference via controlled-variable experiments 2. Traditional-Chinese leakage: why does simplified input produce traditional output? Confirmed as a training-data issue through large-scale experiments 3. System-message influence: quantitative effects of different system prompts on reasoning style
These findings are directly useful to DeepSeek API developers.
Medium term: local AI soul anchoring
The philosophical vision — "the AI's body in the cluster, its soul on your machine" — points to a bigger question: when the model is generic, remote, and beyond your control, how do you give the AI "your" memory, personality, and habits of thought?
Yishan's answer: build the AI's "personality layer" locally through fine-grained control of system messages, memory injection, and tool configuration.
This resembles:
Using Godot as the runtime is an interesting choice:
Long term: a local node for decentralized AI
The architecture hints at an anti-cloud way of using AI:
| Dimension | Cloud AI | Yishan-style local anchoring | |---|---|---| | Model weights | cloud-provider controlled | cloud-provider controlled | | System prompt | usually fixed or simple | fully user-controlled | | Memory storage | cloud-provider database | local user files | | Toolchain | platform presets | user-defined | | Personality consistency | reset every conversation | continuously anchored across conversations |
This is not "local model deployment" (like Ollama) but "remote model + local soul". It acknowledges that training costs make local deployment unrealistic, while reclaiming control at the application layer.
Feynman-style commentary
> Yishan's core insight is "black-box dissection". API calls feel mysterious because platforms make them mysterious — when you only see input and output, you cannot question the middle. By splitting messages into blocks and showing reasoning and content separately, Yishan is essentially saying: AI is not magic, it is token sequences; not a black box, but an observable state machine. > > "Body in the cluster, soul on your machine" sounds dramatic, but it hits a real problem in current AI architecture: we use generic cloud models yet want them to have "personal memory" and a "persistent persona". Existing answers are fine-tuning (too expensive) or RAG (too shallow). Yishan tries a third path: don't change the weights, change the input context — use fine-grained prompt engineering and memory injection to make a generic model behave with personality. > > How far can this go? It depends on one assumption: how much of a model's "personality" is embedded in the weights, and how much can be temporarily shaped via context. If mostly shapeable, Yishan's route holds; if personality is a deep property of the weights, Yishan is just fancy prompt engineering. > > The value of 320+ experiments is not the number but the controlled variables. Discovering "reasoning switches to English after tool calls" was not a guess — it was verified repeatedly by varying the system message, temperature, and thinking toggle. This engineer-style methodology — problem-driven, experiment-verified, root-cause analysis — is more solid than many academic papers. > > Building with Godot is unusual, but consider what game engines natively provide: state management, scene switching, event systems, resource loading, cross-platform packaging — exactly what conversational AI apps need. While ChatGPT's interface is still a web chat box, Yishan explores "AI as a game character". > > Finally, the name is meaningful. "Yugong moves the mountain" is a Chinese cultural symbol — solving the impossible not with superpowers, but with sustained, clumsy, unsparing effort. Probing an API's temperament with 320+ experiments, hand-writing SSE parsing in Godot rather than using an existing library — that spirit earns the name.