AI argues. Code settles. The losses stay on the page.

A real Hong Kong + US brokerage account, run day after day by agents that debate every call before it happens, then settled by code the model never touches. Every result gets published, wins and losses both. Install the same decision workflow into your own agent, in any harness: OpenClaw, Claude Code, Codex, DeepSeek Harness, or one you write yourself.

Live dashboard  ·  Daily briefs  ·  Evidence  ·  简体中文

_{“The market doesn't care how confident the model was.”}

_{Real positions, real P&L, graded in the open. Previews refresh weekly; the live dashboard updates through the trading day.}

What this is

This started as one account, not a package. A multi-agent desk debates the evidence on a real brokerage account with separate Hong Kong and US books and proposes trades; the account owner still places the orders. What comes out of that is the record: real positions, a growing decision history, and a public scorecard the model has no say in — not a get-rich bot, and not a copy-trading service.

clawock is the part of that desk we pulled out and made reusable: an agent-native, harness-agnostic investment decision-workflow plugin with a verifiable harness. OpenClaw, Claude Code, Codex, DeepSeek Harness, or another external runtime keeps the model call, the conversation, memory, planning, tools, permissions and credentials. clawock installs the workflow on top of that: it certifies evidence, forces an opposing case, checks the money and FX arithmetic, links outcomes back to the decision that caused them, and keeps every improvement proposal reviewable and reversible. Swap harnesses and the decision contract stays put — it's just files and a CLI. See examples/ for the same run done from a pure CLI, an OpenClaw skill, a Claude Code instruction, a Codex AGENTS.md, and a DeepSeek Harness agent.

Install it with pip install clawock, or run it on your own book without this repository at all. The model proposes; Python owns the prices, the risk limits, the ledger, the settlement, and the grading.

What makes it different

• A workflow plugin, not another agent — and not another harness. The external runtime keeps its model, chat, memory, skills engine, tool loop, and permissions; clawock makes the investment-decision contract portable across runtimes and across harnesses. The harness debate (OpenClaw vs Codex vs DeepSeek Harness) is a debate clawock does not participate in.
• The loop continues after the answer. Evidence, the opposing case, thesis, decision, execution, and observed outcome share one lineage. Measured results can propose bounded parameter changes, but never silently rewrite strategy.
• Real money, graded in public. One live Hong Kong + US brokerage account, with a public scorecard that keeps every eligible result — the losses included, and the fact that the active calls haven't beaten buy-and-hold.
• The model can't grade itself. LLMs propose trades; Python settles them and computes the scorecard.
• One thesis, one episode. Repeated opinions on the same thesis count once. Each episode is settled from canonical vendor bars, with declared gap-fill rules when a session is missing.
• The ledger has to reconcile. A money-conservation check runs before every push; if cash, positions, and P&L don't balance, nothing is published.
• Built to keep running. Scheduled Hong Kong and US sessions produce bilingual briefs and refresh the live dashboard through the trading day.

How it works

The product boundary is simple: the external agent reads and reasons; clawock owns the portable decision workflow and the deterministic truth around it.

The KCNyu deployment then applies that product boundary to one live portfolio. This second diagram is the deployed KCNyu desk, not the reusable package boundary.

Every trading day the system pulls fresh prices, FX, volatility, earnings and macro context plus news and social sentiment; hands that normalized context to a multi-agent debate; applies deterministic risk, schema, and ledger gates in Python; delivers a brief to WeChat; and updates the public dashboard.

The information layer

Reading the market is most of what the LLM does, so the widest part of the system is data collection. The repository catalogs 41 fetch and compute modules across 8 layers, with bilingual Hong Kong + US coverage — live quotes, SEC + Eastmoney filings, capital flow, earnings calendars, macro (VIX / DXY / 10Y), Reddit and news sentiment, and market-moving social feeds. Each brief consumes the subset relevant to that market and session. Collection stays broad; the decision layer stays constrained.

What each run actually receives

Collection is broad, but no run gets everything. Each scheduled job's preflight assembles only the blocks that job can act on, writes them to a context file, and the model reads that file rather than fetching for itself.

sources
  ──► preflight (Python, deterministic)
  ──► context.json
  ──► LLM prose
  ──► postflight (Python)
  ──► publish

Pre-open gets the most: full position truth, risk, signals, the evidence graph, research state, and it writes the day's plan. The open/midday/close runs travel light — a fresh quote, risk only when signals demand it. Intraday check-ins (every 30 minutes a market is open) sit in between: more signal detail, but no research production and no evidence-graph rebuild, because that is a daily artifact and would be stale by construction.

Influencer radar

The system scans Trump (Truth Social, first-party) and Musk (news aggregation) one to two times a day on the HK/US session clock, then an LLM filters the noise and links what's left to actual holdings and sectors: stance (endorse / oppose), relevance, and a plain-language summary. Who said what, and whether it touches your book, is already sitting in the pre-open brief — nobody has to go scroll social media for it.

A concrete example: on 2026-08-13 Trump announced a de minimis tariff-loophole ruling; the radar matched it to retail/e-commerce and linked it to the Hang Seng Tech position, and the summary landed in the next day's brief. The scan the day before (2026-08-14) found 3 posts and zero holding hits — an empty result is published as an empty result, not skipped. What's shown above is one hit; misses go in the brief exactly as often as they happen.

How it decides

Analysis resolves into explicit, gated strategy decisions — and one stock can carry several at once.

• Several strategies, graded separately. core_position, risk_rebalance, intraday_t, event_trade, and tactical_entry can coexist on the same name, because a long-term thesis and an intraday trade can legitimately disagree. Each is graded in its own episode.
• Attribution-first. Every decision is tagged by its dominant driver, and that driver's edge is measured dynamically from the record — no hit rate is hard-coded into the logic.

Low-frequency add campaigns

Adding to a position needs two independent signals to agree: a price/peer signal (factor rank plus curated-peer residual) and a separate, point-in-time news signal (reliable positive surprise or accelerating attention) — not one moving average mistaken for alpha. Negative information or peer-laggard evidence blocks it outright, sizing stays capped and tranche-based (a warming policy earns a small exploration slice, not validated authority), and a small rank wobble can't churn permission off and on.

• Falsify, don't confirm. In a risk-on tape the default is HOLD. A bullish story doesn't trigger a buy until it clears a disconfirming check and an "is this already priced in?" test on the last few days' move.
• Regime over timing. Leverage isn't timed; a 200-day-trend × volatility dial sets the cap. The backtested lesson: the edge was in de-leveraging in the wrong regime, not in calling tops.

The debate

The daily deep brief runs a structured multi-agent debate, adapted from TradingAgents for separate Hong Kong and US books. More agents isn't the point: the protocol demands an opposing case, and the Judge attributes each resolution to a named strategy frame.

• Analyst lenses. Fundamental, technical, sentiment, and sector-rotation agents read the same context and merge into one table. Every claim must cite numeric context.
• Bull vs Bear. Two researchers build opposing cases, each citing concrete analyst data points. The protocol asks them to genuinely disagree on at least one position and to record it, so unanimous agreement reads as a flag rather than evidence.
• Risk voices + a Judge. Aggressive, Conservative, and Neutral each argue their corner. A Judge weighs them, names the strategy frame driving each decision, and resolves the argument into plan.json — which enters the next session's grading pipeline.

The public scorecard

Every call is settled mechanically and published — wins, losses, and the cases that can't be graded. Nothing is hand-tuned after the fact.

1. Record — the model submits a versioned decision with its strategy, condition, regime, size, and confidence. The authoritative ledger is memory/decisions.jsonl.
2. Trigger — Python evaluates it against canonical unadjusted daily bars, counted on each market's own calendar. An unfinished session grades nothing, and a gap straight through a trigger fills at the open — never at a price that was never available.
3. Group — repeated calls of the same strategy collapse into one episode, so holding a position for five mornings does not manufacture five samples.
4. Grade & publish — code settles the outcome, scores it against a plain directional baseline, and renders it. Shut sessions, calls that need human evidence, and instruments that didn't trade are published as ungradeable — out of the win-rate denominator, but kept visible in the coverage count instead of silently dropped.

The model submits decisions; it can never write or amend its own evaluation. That isolation stops the desk from grading itself — it does not make the market data or the metric definitions correct. Treat the record as a diagnostic, not as proof of return.

_{Cumulative episode win rate against a 50% directional-hit line — how often the direction was right, not what it earned. The buy-and-hold comparison is the Shadow Portfolio under Holdings; this is a different question. Refreshed weekly by GitHub Actions; live figures are on the Holdings tab.}

What we tested, and what failed

The scorecard reports what happened. This reports what was checked — and what did not survive the check.

A layer has to clear a stated bar before it is allowed to influence a decision, and the bar is set before the result is known:

• Factor edges must have a two-way clustered bootstrap interval that does not straddle 50%. An interval that straddles it means the sample is too small, which is a different statement from "the factor does not work" — both keep it out of decisions, and the distinction is published.
• The cross-sectional layer is pre-registered. Only snapshots recorded after registration count toward activation, so a retrospective result can never switch it on.
• The leverage dial is scored out of sample: thresholds are calibrated on a leading window and graded on the next one, and its timing is tested against a null that circularly shifts the same exposure path against returns — preserving its shape and time-in-market while destroying only the alignment.

Results are published whether or not they flatter the system. The dial's permutation test is the current example: on the sample available, its timing cannot be distinguished from chance, and that is stated on the page rather than left out of it. A failure to reject is not a refutation, and the page says which one it is.

Two properties keep this from decaying into copy. The page is generated from the artifacts, so it cannot quietly drift from them. And any backtest figure quoted in the repository has to cite a run card that still contains it — a stale citation points at real evidence that no longer says what the claim says, which reads as credible and is wrong. CI fails on both.

Evidence and refutation

What the code enforces

The model writes opinions. The arithmetic that could corrupt the record runs in Python and is unit-tested.

That path is covered by a large unit-test suite — it's what keeps the system stable. Currencies never sum (HKD and USD are shown separately, rate and timestamp stamped), risk caps are checked every brief (single name ≤35%, Top-2 ≤70%, portfolio β ≤3.0, stop at −18%), and a thesis moves only on new evidence, never on a price move alone.

Daily rhythm

overnight  memory "dreaming" — promote yesterday's lessons into long-term notes
morning    deep brief — multi-tier debate + a judge, ships to WeChat
HK session open → scheduled intraday monitors → close
US session open → split intraday monitors → close
             ↑ every successful reporting run publishes dashboard changes
around it  pre-brief macro / sentiment / event scans, then a pre-US-open news digest
weekly     archive, health, review, and visual-refresh jobs

Hong Kong times run on HKT; US session times follow ET and their cron expressions shift automatically with New York DST. A holiday + weekend gate skips closed sessions. The exact generated table is in docs/operations/cron-schedules.md.

Run it on your own book

The package lifecycle is no longer welded to this account's directory. It is published to PyPI through GitHub trusted publishing — no API token, and the release job proves a clean environment can install the exact artifact and finish a run before it uploads:

python -m pip install clawock
clawock workflow install investment-decision --workspace ./my-decision
clawock init ./my-decision --workflow investment-decision
clawock run prepare --workspace ./my-decision

You need Python ≥ 3.11 and an agent that can read a file and write decision.json — any harness works, and the model call stays entirely in your runtime. The emitted request is for the external agent to consume. The agent writes decision.json; clawock run publish validates it and emits the correlated generation receipt. The packaged example can smoke the lifecycle without a model (bash examples/cli/minimal-run/run.sh), and examples/ shows the same run driven from a pure CLI, an OpenClaw skill, a Claude Code instruction, a Codex AGENTS.md, and a DeepSeek Harness agent — the harness never touches the contract.

Same contract, whatever the harness looks like

Two harnesses, two completely different interfaces, one decision.json on each side. Claude Code stays a terminal loop — prepare, read, write, publish:

DeepSeek Harness gets a native panel instead — one command installs the skill plus a conversation-view tab:

dsh plugin --profile web add clawock-dsh

The Decision Mind tab is one view, not three tabs: the spine is your real fills (portfolio.json trades), each row carries the soft-paired decision (±3 days from decisions.jsonl) as the "why", and the T+1 snapshot close decides 卖飞/卖对 on sells. Click a fill and the trace unfolds — plan → execution → T+1 → P&L — with the rationale and note in semantic colors, plus an emotion-pressure field on the small number of records that logged one so far. Fills with no decision say so explicitly, instead of making one up. Currency is never mixed: USD and HKD stay apart and only combine through the desk's published FX rate. The same trace data powers the public dashboard's Reflect card, so the plugin and the website render one contract:

Conversation verdicts land in the same ledger through one command from any harness: clawock record --source <harness> (bear case and invalidation conditions mandatory, emotion pressure self-reported). Nobody edits decisions.jsonl by hand — one ledger, one record command, every harness calls it.

For the KCNyu compatibility surface, clawock doctor, clawock context audit, and CLAWOCK_WORKSPACE still inspect or point at an operational book. They name missing capabilities instead of pretending every foreign workspace is ready to run this live desk.

The package owns lifecycle implementation, strategies, scheduling, watchdogs, generation-pinned artifacts, context assembly, validation and CLI. It does not reimplement an agent loop: OpenClaw is the unattended runtime used by this desk today, while another runner can consume the same context/tool contracts. The kcnyu profile and workspace declare this desk's books, resources and schedules; doctor and context audit state those capabilities instead of pretending every foreign workspace is production-ready.

Explore the system

• Live dashboard — positions, risk, and the self-graded scorecard.
• Daily briefs — the published morning reads.
• Examples by harness — one decision run, five harnesses: pure CLI, OpenClaw, Claude Code, Codex, DeepSeek Harness, plus the npm DSH plugin.
• Schedule — the generated cron table.
• Command reference — every installed command, generated from the registries, plus the hand-written provider and harness detail.
• Project docs — operations, reference, legal notes, and archived designs.

Research surfaces

These surfaces chain in one direction — entry gate, then first-party earnings evidence, then the canonical thesis and its evidence-only drift, then the existing decision, risk and settlement loop. Each step writes a versioned artifact the next one reads, so a later stage can never quietly re-derive an earlier one from prose.

These are workspace-native research routes, not standalone one-command products. They expect clawock's scripts, data contracts, and memory/SOP files; the published portfolio and its operating history remain specific to this deployment.

Built with Claude Code, the openclaw cron daemon, a static Jekyll + GitHub Pages frontend, and Python. Market, news, macro, and sentiment come from documented public sources with multi-source fallback; see third-party data and service terms before reusing any fetched content.

Scope, disclaimer, and license

This repository holds real trading positions. It is a personal record and portable workspace — not investment advice, a recommendation, or a copy-trading system. The desk analyzes and proposes; it does not place orders for you. No individual outcome is hand-picked — settlement rules and methodology changes are versioned in code — the active calls have yet to show an edge, and every number may be stale by the time you read it.

Original code is under the MIT License. Adapted third-party code keeps its own license and attribution in NOTICE and THIRD_PARTY_LICENSES/. Third-party market data, news, social posts, filings, trademarks, and API access are not relicensed by MIT — see Third-party data and services.