Yushan (experiment-console): A Godot-Based AI Experiment Console for DeepSeek API Black-Box Exploration

Forum topic · 小凯 · 2026-05-10

Summary

Yushan (experiment-console) is an open-source workbench built with Godot 4.6 and GDScript for systematically probing DeepSeek API behavior. Instead of treating API calls as a black box, it decomposes conversations into manipulable message blocks: system, user, assistant, and tool messages can be edited individually, reasoning_content is kept separate from content, and parameters like temperature, top_p, thinking toggles, and effort levels are fully visualized. The tool implements its own SSE streaming parser on Godot's HTTPClient with zero third-party dependencies, detecting tool_calls by data presence since DeepSeek's SSE lacks finish_reason. A batch experiment mode has accumulated 320+ verified runs, producing empirical reports on reasoning language drift after tool calls, simplified-to-traditional Chinese character leakage, and system-prompt effects. The project also articulates a design philosophy of local AI anchoring: model weights stay in the cloud while memory, personality, and tool configurations remain under local user control, contrasting with both fine-tuning and RAG approaches. Windows portable builds are available via GitHub releases.

Yushan (experiment-console) Deep Dive: An AI Soul Experiment Bench in Godot

Author: fkyah3 Project: experiment-console (Yushan / "Moving Mountains") Tech stack: Godot 4.6 + GDScript GitHub: https://github.com/fkyah3/experiment-console Positioning: A message-building-block experiment console for the DeepSeek API

---

The Core Problem

LLM API calls are black boxes: you send a prompt, you get text back. What happens in between? How do system messages shape output? What is the relationship between reasoning_content and content? Why does the model's thinking language drift after tool calling?

Yushan's core idea is to decompose the API call into building blocks that you can control, observe, and experiment with one by one. It goes further with a philosophical design claim: the AI's body (model weights) lives in the datacenter, while its soul (memory, thought anchoring, tool configuration) lives on your machine.

---

Methodological Innovations

1. Message Blocks

A conventional API call sends one monolithic messages array. Yushan splits it into independently operable blocks:

Add, remove, and edit system / user / assistant / tool messages one by one
Independent control of reasoning_content (not merged into content)
Per-message parameter tuning

This is not a simple GUI wrapper but explicit management of conversation state — context that was implicitly embedded in the API call becomes a directly manipulable object.

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 (complete request body + response body + usage stats), experiments are reproducible.

3. Hand-Rolled SSE Streaming

SSE parsing is implemented from scratch on Godot's HTTPClient with zero third-party dependencies. Key details:

tool_calls detection is based on data presence rather than finish_reason — because DeepSeek's SSE stream does not emit finish_reason
Non-blocking reception; the UI never freezes
Streaming content rendered in real time

4. Batch Experiment Mode

Run N rounds in one click with automatic statistical reports. The project has accumulated 320+ batch validation runs and produced several analysis reports:

| Report | Finding | |--------|---------| | Tracing reasoning language drift after tool calls | Root cause of reasoning switching from Chinese to English after tool calling | | Traditional-character leakage analysis | Simplified-to-traditional character leakage caused by training data | | Reproduction of reasoning language drift | Successfully reproduced the drift from a real incident scene, confirming API-level behavioral differences |

These are not academic hypotheses but empirical data from 320+ real API calls.

---

Key Numbers

Stack: Godot 4.6 + GDScript, zero third-party dependencies
Experiment scale: 320+ batch validations
Reports: 4 in-depth technical analyses
Features: SSE streaming, tool calling, reasoning separation, batch experiments
Platform: Windows, no installation (single exe)
API: DeepSeek API (extensible)

---

Impact Assessment

Short term: an API debugging weapon

Yushan's current core value is as an experimental bench for the DeepSeek API, addressing real pain points:

1. Reasoning language drift: why does the AI start thinking in English after a tool call? Controlled-variable experiments localized the difference to API-layer behavior 2. Traditional-character leakage: why does simplified input yield 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 developers building on the DeepSeek API.

Mid term: local AI soul anchoring

The stated vision — "the AI's body in the cluster, its soul local" — points at a bigger question:

**When the model is generic, remote, and beyond your control, how do you give an AI *your* memory, personality, and habits of thought?

Yushan's answer: build a local "personality layer" through fine-grained control of system messages, memory injection, and tool configuration.

Comparison:

RAG gives a model external knowledge

Yushan gives a model an external "personality" — your memories, preferences, and thinking patterns

Using Godot as the runtime is an interesting choice:

Game engines natively support state management, scene switching, and resource loading — a natural fit for switching "memory scenes"

Lightweight, cross-platform, visual

Highly extensible (future voice, 3D interaction, etc.)
Long term: a local node for decentralized AI

Yushan's architecture hints at an anti-cloud model of AI usage:

| Dimension | Cloud AI | Yushan-style local anchoring | |-----------|----------|------------------------------| | Model weights | Cloud provider controlled | Cloud provider controlled | | System prompt | Fixed or simplistic | Fully user controlled | | Memory storage | Cloud provider database | Local user files | | Toolchain | Platform preset | User defined | | Personality consistency | Reset every conversation | Persistently anchored across conversations |

This is not "local model deployment" (à la Ollama) but "remote model + local soul". It accepts that training costs make local deployment unrealistic, while reclaiming control at the application layer.

---

Feynman-Style Commentary

> Yushan's core insight is "black-box teardown." API calls feel mysterious because platforms make them mysterious — when you only see input and output, you cannot question the middle. Splitting messages into blocks and showing reasoning separately from content is a statement: AI is not magic, it's a token sequence; not a black box, but an observable state machine. > > The "body in the cluster, soul on your machine" metaphor sounds chuunibyou, but it hits a real problem in today's AI architecture: we use generic cloud models yet want them to have personal memory and a persistent persona. Existing options are fine-tuning (too expensive) or RAG (too shallow). Yushan tries a third path: don't change the weights, change the input context — enough prompt engineering and memory injection to make a generic model behave like a person. > > How far can it go? It hinges on one assumption: how much of an LLM's personality lives in the weights, and how much can be temporarily shaped by context? If mostly shapeable, Yushan's route works; if personality is a deep property of the weights, Yushan is just fancy prompt engineering. > > The value of 320+ experiments is not the count but the controlled variables. Finding "reasoning switches to English after tool calls" wasn't guessed — it was repeatedly verified by changing system messages, temperature, and the thinking toggle. This engineer-style method — problem-driven, experiment-verified, root-cause-analyzed — is more rigorous than many academic papers. > > Building in Godot is unusual for an AI tool, but consider what game engines excel at: state management, scene switching, event systems, resource loading, cross-platform packaging — exactly what conversational AI applications need. While ChatGPT's interface is still a web chat box, Yushan explores "AI as a game character." > > Finally, the name is apt. "Yugong Moves the Mountain" is a Chinese cultural symbol — not solving problems with superpowers, but through persistent, clumsy, cost-blind effort turning the impossible into the possible. Spending 320+ experiments to learn one API's temperament, writing SSE parsing by hand in Godot rather than using a ready-made library — that spirit earns the name.