Skip to content
BranchesTags

Repository files navigation

Catalyst

Catalyst is a governed Bitget trading Playbook: Qwen proposes trades, deterministic risk approves or refuses them, and every decision becomes a public receipt.

It is not copy trading, not a market-analysis chatbot, and not a black-box bot. Catalyst turns a trading idea into an execution script with market conditions, monitored signals, triggers, risk limits, stop rules, and a receipt for every approval or refusal.

Submission Summary

Review In 90 Seconds

  1. Open the live app: https://trycatalyst.vercel.app
  2. Read the first screen: it shows the current market, Qwen action, governor verdict, receipt checksum, and ledger impact.
  3. Open Latest receipt to inspect the raw cycle JSON.
  4. Open Ledger to see the receipt history, forward grading, calibration, and browser checksum verifier.
  5. Open Evaluator pack for the one-page proof bundle and the exact local verifier commands.

The core claim to verify is simple:

Signal scan -> Qwen thesis -> deterministic governor -> approval/refusal receipt -> forward ledger

Why Judges Should Care

Catalyst's product moment is not "an AI placed a trade." It is "an AI had a thesis, the risk layer could say no, and the system proved the decision either way."

  • Load-bearing sponsor stack: Bitget market data drives the scan, Qwen writes the thesis, Agent Hub contributes context, and GetAgent supplies the completed Playbook run proof.
  • Reproducible proof surface: the live receipt, forward ledger, paper log, evaluator pack, and local verify:all gate all point at the same public artifacts.
  • Honest boundary: the trading record is paper/backtest only. Catalyst claims disciplined autonomous execution and verifiable refusal, not real-capital PnL or guaranteed profit.

Latest committed ledger snapshot:

Metric Value Why it matters
Autonomous cycles 176 public scheduled receipt runs in the current evaluator pack
Approved trades 20 resolved paper trades allowed by the governor
Approved win rate 60.0% resolved approvals only
Refused setups 85 vetoes + 70 stand-downs Qwen theses the governor blocked or refused to chase
Discipline alpha +4.1518% approved simulated PnL minus forced-counterfactual PnL

Metric-source split:

GetAgent backtest: 70% win rate over 20 backtest trades, run pbrun-b8eb40e05307.
Live ledger:       60.0% approved win rate over 20 governor-approved paper trades in the current evaluator pack.

Live vs Simulated Boundary

Surface Mode What it proves Public artifact
Latest autonomous cycle Live scheduled receipt Qwen thesis, governor decision, and checksum from the current cycle https://trycatalyst.vercel.app/demo-data/latest-cycle.json
Forward ledger Receipt-derived simulation shadow How approvals and refusals are graded across committed cycles https://trycatalyst.vercel.app/demo-data/forward-ledger.json
Paper trading log Track 1 paper trading Balance-changing paper trades allowed by the governor https://trycatalyst.vercel.app/demo-data/paper-trading-log.csv
GetAgent Playbook proof Completed API backtest Sponsor-native run metrics for Catalyst Discipline https://trycatalyst.vercel.app/playbook-proof.json
Historical trade-cleared replay Replay proof The UI/proof path can show an APPROVE decision when risk clears https://trycatalyst.vercel.app/demo-data/trade-cleared.json

Catalyst does not claim real-capital PnL, guaranteed returns, or a public GetAgent Studio leaderboard rank. The submission claim is narrower and stronger: the governed loop is live, receipt-backed, paper-traded, and reproducible.

Under-200-Word Project Description

Catalyst is a governed Bitget trading Playbook that treats NO TRADE as the default. It scans BTC, ETH, and SOL using Bitget market data, Agent Hub signals, derivatives positioning, and Qwen reasoning. Qwen writes the thesis, but it cannot execute directly. A deterministic governor checks signal coverage, conviction, volatility, momentum, and stop discipline before allowing a rule-based paper execution. If risk fails, Catalyst records a veto or stand-down receipt instead. The live app exposes the current decision, checksum-backed receipt, forward ledger, paper-trading log, GetAgent proof, and evaluator pack. The point is not guaranteed profit; the point is a complete and reviewable perception -> decision -> risk -> execution/simulation loop where an autonomous agent can act, refuse, and prove both.

Why This Exists

Most trading bots optimize for activity. Catalyst optimizes for disciplined execution.

An autonomous trading agent should not trade just because a model can produce a thesis. Catalyst separates reasoning from permission to act:

  1. Scouts collect market context from Bitget, Agent Hub, and derivatives signals.
  2. Qwen writes a structured trading thesis.
  3. A deterministic governor checks whether the thesis is allowed to act.
  4. The system writes a checksum-backed receipt whether it trades or refuses.
  5. The forward ledger grades approvals and refused counterfactuals on the same out-of-sample basis.

This directly maps to the Bitget Track 1 loop:

perception -> decision -> execution/simulation -> risk management -> receipt

Current Public Proof

Proof Status Where to verify
Live app Ready https://trycatalyst.vercel.app
Latest live autonomous cycle Auto-updating public/demo-data/latest-cycle.json
Historical trade-cleared replay APPROVE / TRADE public/demo-data/trade-cleared.json
GetAgent Playbook run Completed API run public/playbook-proof.json
Cycle history Indexed public/demo-data/cycles.json
Forward ledger Indexed public/demo-data/forward-ledger.json
Track 1 paper trading log Indexed public/demo-data/paper-trading-log.csv
Market scan proof Indexed public/demo-data/scan.json
Evaluator pack Indexed public/demo-data/evaluator-proof.json

Latest strict receipt:

source:   https://trycatalyst.vercel.app/demo-data/latest-cycle.json
cadence:  every 4 hours via GitHub Actions
contains: market, Qwen thesis, governor decision, sim result, checksum

GetAgent run evidence:

Playbook: Catalyst Discipline
Market:   SOLUSDT
Status:   completed
Window:   2026-03-01 to 2026-06-06
Return:   +0.03% strategy basis / +0.15% account basis
Sharpe:   2.635
Drawdown: -4.82% strategy basis / -0.02% account basis
Win rate: 70%
Trades:   20
Run:      pbrun-b8eb40e05307

public/playbook-proof.json is the public source of truth for GetAgent evidence. Catalyst does not claim a public GetAgent Studio leaderboard rank or published URL unless that URL is reproducible by judges.

Forward Ledger: Shadow-Audited Discipline

Catalyst does not only show a backtest. It keeps a public ledger from the autonomous cycle receipts in receipts/cycles. Current resolved rows use the shadow-audit data already embedded in each committed receipt; stricter post-commit forward samples can keep accumulating as future cron receipts arrive.

The current ledger snapshot is regenerated into the public evaluator pack and forward ledger on every autonomous cycle:

source:       https://trycatalyst.vercel.app/demo-data/forward-ledger.json
paper log:    https://trycatalyst.vercel.app/demo-data/paper-trading-log.csv
updates:      every autonomous cycle
review page:  https://trycatalyst.vercel.app/evaluator/
raw bundle:   https://trycatalyst.vercel.app/demo-data/evaluator-proof.json

The current live app surfaces the latest veto/approval count directly from the ledger. The shadow baseline is simulation-only: approved simulated PnL minus the risk-controlled counterfactual PnL of Qwen theses the governor refused. Approved trades resolve from the same committed out-of-sample shadow window as the refused counterfactuals, so the approved-trade win rate is reported on identical footing. This is not real-capital PnL, not financial advice, and not a profit guarantee. If the number turns negative in a future window, it stays visible; the credibility is the public, non-cherry-picked record.

GitHub is the notary: the scheduled workflow commits each receipt and the ledger to main, so the public push history timestamps every decision before the market resolved it. The claim is that GitHub recorded the push, not that a commit timestamp is unforgeable.

How Catalyst Works

1. Market Scan

Catalyst scans BTC, ETH, and SOL using real Bitget futures candles. The scanner ranks candidates before Qwen sees them, so the model is not choosing a market from a blank prompt.

Relevant files:

2. Perception Layer

Catalyst combines:

  • Bitget candles and momentum
  • Bitget derivatives funding/open interest
  • Agent Hub technical-analysis
  • Agent Hub macro-analyst
  • Agent Hub news-briefing
  • Qwen thesis generation through the Bitget hackathon proxy

When an upstream Agent Hub feed is unavailable, Catalyst labels cache/fallback context explicitly and does not count it as independent live convergence. The agent does not invent missing signals.

3. Qwen Thesis

Qwen receives the selected market and structured signals, then returns:

  • asset
  • action
  • direction
  • conviction
  • rationale
  • invalidation condition

Qwen can propose a trade, but Qwen cannot bypass risk.

4. Risk Governor

The deterministic governor is the execution gate. It checks:

  • live signal coverage
  • conviction floor
  • volatility cap
  • momentum extremes
  • stop-loss discipline

If any required risk check fails, Catalyst returns STAND_DOWN or VETO.

The latest live receipt is read from public/demo-data/latest-cycle.json, so the displayed state can change as the scheduled agent runs. It may approve, veto, or stand down; the point is that the governor records the decision and checksum every cycle. The forward ledger separately tracks how refused theses would have behaved if forced.

5. Receipts

Every cycle produces a checksum-backed JSON receipt containing:

  • market data source
  • signal snapshot
  • Qwen thesis
  • council/scout votes and governor resolution
  • governor checks
  • execution/simulation result
  • checksum

The browser verifier on the live app recomputes the receipt checksum. If the embedded receipt is changed, the verifier flips from PASS to FAIL.

What Is Real vs. What Is Not Claimed

Real:

  • Real Bitget market data is used in strict cycles.
  • Qwen is used through the Bitget hackathon proxy.
  • Agent Hub technical, macro, and news skills are integrated when reachable.
  • GetAgent returned a completed Catalyst Discipline API run, mirrored in public/playbook-proof.json.
  • The live app is generated from public JSON proof artifacts.
  • Receipts are checksum-verifiable.
  • The forward ledger is regenerated from every strict cycle receipt in receipts/cycles.

Not claimed:

  • Catalyst does not claim guaranteed returns.
  • The latest live cycle is not claimed as a profitable trade.
  • The forward ledger is not claimed as real-capital PnL.
  • The historical trade-cleared replay is not claimed as the latest live cycle.
  • The seeded approval fixture is only a local/UI fallback, not sponsor validation.
  • No public GetAgent leaderboard rank or Studio publish URL is claimed without a reproducible public link.
  • No real user funds are required for the hackathon proof.

Repository Structure

.
├── playbooks/catalyst-discipline/   # GetAgent Playbook package
├── public/                          # Static public demo output
│   ├── demo-data/                   # Receipts, cycles, scan proof
│   └── playbook-proof.json          # GetAgent proof summary
├── receipts/                        # Local receipt history
├── scripts/                         # Cycle, replay, validation, deploy helpers
└── src/                             # Agent, scanner, governor, receipts

The deployed Vercel site uses npm run build and serves the generated public/ directory. Catalyst intentionally ships as a static proof surface so judges see the exact committed receipt artifacts without a second preview stack.

Run Locally

git clone https://github.com/dolepee/catalyst.git
cd catalyst
npm install
cp .env.example .env

The root install covers the agent, receipt, and static demo commands.

Fill the environment variables you have in .env.

Required for the full strict proof path:

BITGET_API_KEY
BITGET_SECRET_KEY
BITGET_PASSPHRASE
BITGET_QWEN_API_KEY
BITGET_PLAYBOOK_API_KEY

Never commit real keys.

Core Commands

Run the test suite:

npm test

Check Agent Hub reachability:

npm run check:agent-hub

Run the strict autonomous cycle:

npm run cycle:strict

Validate the current receipt:

npm run verify:receipt

Verify the decision pair:

npm run verify:decision-pair

Build the static public demo:

npm run forward:ledger
npm run build

Preview the generated site locally:

npm run dev

GetAgent Playbook Commands

Validate the Playbook package:

npm run playbook:validate

Package it:

npm run playbook:package

Upload and run a cloud backtest:

npm run playbook:upload
npm run playbook:run
npm run playbook:summary -- --write-public

npm run playbook:publish exists, but publishing mutates GetAgent state and should only be run intentionally. The current submission claims the completed GetAgent API run in public/playbook-proof.json, not a public Studio leaderboard rank.

Verification Output

Current decision-pair verifier output should show valid: true for both the newest live cycle and the stable historical trade-cleared replay. The exact latest live decision changes as the cron produces new receipts.

{
  "valid": true,
  "results": [
    {
      "label": "latest live cycle",
      "decision": "STAND_DOWN | VETO | APPROVE",
      "proofMode": "live_current"
    },
    {
      "label": "trade-cleared replay",
      "decision": "APPROVE",
      "proofMode": "historical_replay"
    }
  ]
}

The first receipt is the latest live autonomous cycle. The second keeps a stable historical replay in the proof bundle so judges can compare against a known trade-cleared artifact.

Scheduled Autonomy

The GitHub workflow .github/workflows/catalyst-cycle.yml runs every four hours.

It:

  1. runs tests,
  2. runs a strict Catalyst cycle,
  3. rebuilds the forward ledger,
  4. rebuilds the static public site,
  5. commits updated receipt artifacts,
  6. lets the connected Vercel Git integration publish the committed public/ proof surface.

Local gate: npm test and npm run verify:all pass. verify:all checks receipt integrity, decision-pair proof, discipline alpha, calibration, council-drift from committed receipts, paper-trading-log drift, and evaluator-pack drift.

Track 1 Requirement Mapping

Bitget Track 1 requirement Catalyst status
Public demo link https://trycatalyst.vercel.app
Project description under 200 words Included above
Perception -> decision -> execution -> risk loop Implemented
Backtest or sim trading records GetAgent API run + replay receipts + Track 1 paper log
Paper trading log fields public/demo-data/paper-trading-log.csv includes timestamp, pair, direction, price, quantity, and balance change
Bitget AI modules used Agent Hub, Qwen, GetAgent Playbook run, Bitget market data
Demo video Optional for Track 1 because the live demo is public and login-free
Verifiable usage evidence Receipts, checksums, forward ledger, GitHub workflow, GetAgent run, live app

Known Limitations

  • Agent Hub feeds can be intermittently unavailable. Catalyst labels fallback rows and excludes them from live convergence counts.
  • A prior public-publish upload path returned a GetAgent validation error for a shorter public backtest window. The submission therefore does not claim a public Studio rank; it claims the completed 90+ day API run and the live paper-trading ledger.
  • This is hackathon proof on Bitget data and simulated/backtested execution, not financial advice and not a guarantee of profit.

Submission Links

About

Autonomous Bitget trading agent with Qwen reasoning, risk-governed receipts, and GetAgent Playbook proof

catalyst-lac-theta.vercel.app

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages