jcp: a desktop A-share analysis app where several AI agents argue with each other

A desktop app whose central idea is a meeting room

The project is called 韭菜盘, roughly a slang term for retail speculators, and the subtitle describes it accurately: an AI-driven intelligent stock analysis system with multi-agent collaboration. The interesting part is not the market data, which is available many places, but the meeting room. Four agent personas are defined, each with a narrow job: a technical analyst reading chart patterns and indicators, a fundamental analyst interpreting financial statements and valuation, a sentiment analyst tracking market mood and hot topics, and a risk specialist assessing risk and position size.

Instead of one model producing one answer, the agents discuss, and the meeting system supports multiple rounds, MCP tool calls, and automatic retry when an agent fails. The stated purpose is multi-dimensional analysis rather than a single view.

The honest reading of this design is worth stating plainly. The personas are prompt configurations over the same underlying market data and the same model class. They widen the surface you read, and they make disagreement visible, but they do not create independent evidence. Four agents agreeing tells you little that one careful agent would not, and four agents converging on the same wrong read is the expected failure mode. Treat the output as a structured argument to check, not as a consensus signal.

The repository is Go 1.24 with React 18 and TypeScript on the front end, built on Wails v2, with TailwindCSS and Lucide icons for the interface.

Getting it built and the model providers you configure

The prerequisites are Go 1.24 or newer, Node.js 18 or newer, and the Wails CLI v2, which you install with:

go install github.com/wailsapp/wails/v2/cmd/wails@latest

Then clone, install both dependency trees, and run in development mode:

git clone https://github.com/run-bigpig/jcp.git
cd jcp

cd frontend && npm install && cd ..

go mod download

wails dev

`wails build` produces a release binary for the current platform, and the README shows the same command with a platform flag for Windows, macOS and Linux, such as `wails build -platform darwin/amd64`.

Configuration happens on first run through the settings icon in the top right. The README's numbered steps tell you to pick a provider, paste an API key and save, with the file landing in `data/config.json`. Here is the inconsistency to notice: the project description and the feature list advertise OpenAI, Google Gemini, DeepSeek, Kimi and GLM through OpenAI-compatible interfaces, but the setup steps name only OpenAI and Gemini. The `go.mod` dependency list supports the wider claim, since it pulls in `sashabaranov/go-openai` alongside `google.golang.org/genai` and `google.golang.org/adk`. Release 0.3.4 added handling for `max_tokens` against `max_completion_tokens` with automatic and manual switching, explicitly to improve compatibility with GPT-5 and newer OpenAI-compatible endpoints, and added a token parameter mode setting. So the OpenAI-compatible path is being actively patched, but confirm your provider in the settings screen before relying on it.

Market data, the TDX source, and why that matters

Data plumbing is where this project does more work than a typical chat wrapper. The feature list includes real-time quotes, K-line charts at multiple periods, and level-two order book depth, plus hot-topic aggregation from Baidu, Douyin, Bilibili and Toutiao, and a research report service.

Release 0.3.4 is the one that changed the data layer most, and the notes are specific. A TDX market data source was added, bringing real-time quotes, K-line, index and stock search capabilities, together with a primary and fallback source switching mechanism. The stated reason is coverage: relying only on Sina data left gaps and latency, especially for new-share search and data retrieval. The same release added per-stock F10 analysis with a backend service, data models, tool registration and a frontend panel, plus market context and order-book movement features, and it corrected the index change baseline to use the previous daily close rather than a different reference.

That last fix is a useful signal about the maturity of the piece. An index showing a wrong percentage change is a small bug with a large credibility cost, and it shipped. Treat every number in the interface as something to sanity-check against your broker before acting on it.

Version 0.3.5, published the same day as the last push on 2026-04-09, contains exactly one change: a fix for tool call failures, contributed as pull request 45. Small and specific releases like that are easier to reason about than large ones.

Per-stock memory with TF-IDF retrieval and automatic compression

The memory system is the part with a real design, rather than being a prompt wrapper. Each stock gets an isolated memory space so discussions about one holding cannot contaminate another. Within a stock, three structures are kept: a list of key facts covering facts, opinions and decisions, the most recent N rounds of discussion in detail, and an LLM-generated summary of earlier history.

Retrieval is TF-IDF keyword matching rather than embeddings, which is an honest choice for a local single-user desktop app: it needs no vector database, no embedding API calls and no network round trip. The trade-off is that synonym matching is poor, so a memory filed under one phrasing will not be recalled by a different phrasing of the same idea.

The other mechanism is automatic compression. When memory exceeds a threshold, older material is compressed to keep the context window bounded, which prevents the slow failure where an agent's context fills with old chatter and the newest rounds get less weight.

Data lives under `data/memory/`, one file per stock code. The strategy system sits alongside it: you can create multiple strategies, each containing a different combination of agents, and configure an independent AI model per agent or per strategy. That per-agent model assignment is the feature that lets a fast cheap model handle sentiment lookups while a stronger model handles valuation, and it is the most practically useful knob in the whole application.

Extending it with MCP tools and adding your own agent

The project supports the Model Context Protocol, with `modelcontextprotocol/go-sdk` at version 0.7.0 in the dependency list. The documented tool capabilities are real-time quote queries, K-line data, level-two order book depth, news search, research report lookup and hot-topic retrieval. So the agent system can fetch data during a discussion rather than working from context alone.

Adding your own tool is a three-step process the README lays out concretely: create the tool file under `internal/adk/tools/`, implement the `Tool` interface, then register it in `registry.go`. That is a normal Go interface registration, and `internal/adk/` is described as an AI development kit.

Adding an agent is different and simpler: edit `data/agents.json` and set the agent's name, role and system prompt, then restart the application for it to take effect. Because agents are configuration rather than code, you can experiment with prompts cheaply, which is the practical way to find out whether the multi-agent framing earns its token cost in your own workflow.

A few other pieces are worth knowing about. `google.golang.org/adk` at version 0.4.0 is in the dependency list, and the project integrates an OpenClaw service described as providing AI-driven deep stock analysis. Market state management schedules around trading hours and recognises open, close and holiday states automatically. Charting uses Lightweight Charts from TradingView in place of Recharts. Window and panel layout is persisted and restored on the next launch, which sounds minor and is the difference between a tool you use daily and one you reinstall.

Licensing, versioning and where the README disagrees with the repository

Two things need flagging before you rely on this. The first is licensing. The README states the project uses the MIT licence and links a `LICENSE` file, and the badge at the top of the README says MIT as well, but the repository's own licence metadata records no recognised licence type. The `LICENSE` file is present in the tree. Where a README assertion and the repository's licence field disagree, the file is the more reliable source, and you should read it before redistributing anything. This article does not give legal advice; it only notes that the two signals are not aligned and that checking the file costs nothing.

The second is versioning. The README badge says version 0.3.0, while the newest tag in the repository is v0.3.5. The badge has simply not been updated, and the releases page is the authoritative list.

There is a third smaller oddity. The project structure block in the README opens with a root directory named `ccjc/`, while the clone instructions and the repository URL both use `jcp`. The tree confirms the repository root is the project itself, with `main.go`, `app.go`, `wails.json`, `frontend/`, `internal/`, `data/`, `build/`, `image/` and a `skill/` directory at the top level.

For calibration, the last push was on 2026-04-09 and the repository has four open issues and a contributor list of five named people. That is an early-stage project with real code behind it, and the mismatch between the badge, the licence field and the directory name is a reminder to verify facts from the repository rather than from the README page.

Editorial conclusion

jcp is worth installing if you trade the Chinese A-share market and want a desktop workbench that puts chart, order book and a multi-model debate in one window. The parts that hold up are the data plumbing, the strategy and memory systems, and the willingness to point it at a TDX source rather than one fragile scraper. What it does not do is give you an edge: four personas reading the same indicators through the same API will converge on the same read, and the project is candid that it is an analysis tool rather than a signal. Check three things first. The README's setup section names only OpenAI and Gemini while the feature list claims DeepSeek, Kimi and GLM compatibility, so confirm your provider works before committing. The version badge reads 0.3.0 while the newest tag is v0.3.5, so trust the releases page. And the last push was on 2026-04-09, with v0.3.5 shipping only a tool-call fix, so expect a young project with a small issue backlog.

Frequently asked questions

Official sources

1. Issues
2. README
3. Releases
4. run-bigpig/jcp on GitHub