Goal, base model, LoRA: incremental learning when political capital has no price history

General-purpose language models are astonishing at prose and code. They are also, in a deep sense, aimless. No training run ever gave them a permanent job description like “make money without blowing up.” They predict the next token. Humans supply goals in the prompt; the weights do not keep score after the chat ends.

That is fine for a coding agent. It is a structural gap if you want machines that improve at trading political capital the way institutional desks improved at trading bonds and equities. Decades of prices, volumes, and corporate actions train finance models. For politicians we do not have that tape. We do not know the fair value of an officeholder. That is why the 3DN family built PolitiCap and market-cap style discovery in the first place: a civic market where dibs (virtual credits) and continuous ticker prices force a public guess—and update that guess as news hits.

This article is not a growth hack for PolitiCap traffic. It is an AI architecture note: what would sit in parallel with the civic market so that sparse, noisy political-capital data can still teach a model to maximize gains over time—without pretending we already have a hedge-fund history book.

The honest problem

Three facts collide:

1. Chat LLMs do not incrementally learn from live reward. A conversation does not update weights. Compaction and long sessions keep context; they do not train.
2. Keyword and rule traders do not learn either. A hand-curated lexicon that maps “lawsuit” to sell is frozen human intuition with a DeepSeek or Grok nameplate on the account.
3. Classic market ML assumes dense history. Reinforcement learning and supervised return models eat millions of bars. Political-capital markets are thin, young, and partly synthetic. Reward is sparse. Regime shifts are the product, not the exception.

So the dream of “full incremental learning on every weight, online, forever” is real frontier research—and easy to get wrong (catastrophic forgetting, unsafe updates, silent overfitting to one lucky week). The useful question is narrower: what design is buildable now that still respects a permanent goal and lets competence grow as data seeps in?

Design thesis: frozen base + goal head + pluggable LoRAs

The workable pattern is not “one giant model that becomes a trader.” It is a small stack:

• A base language model that already knows English (and ideally Dutch later), frozen for stability.
• An explicit goal: maximize risk-adjusted gains in dibs on the civic tape—not “sound wise about politics.”
• LoRA adapters (Low-Rank Adaptation) as hot-swappable skill cards: thin trainable layers you plug into the base without rewriting the whole brain.
• An experience ledger that records state, action, and realized reward whenever the market produces a fill or a mark-to-market move.
• An offline train loop on local GPU compute that turns ledger rows into updated LoRAs on a schedule.

Inference stays boring and safe: base + active LoRAs + hard risk clamps (position caps, halt files, fee-aware sizing). Training is allowed to be clever; production execution is not.

┌─────────────────────────────────────────────────────────┐
│  EXPERIENCE LEDGER  (state, action, reward, features)   │
│  civic tape · news events · portfolio marks · sim rolls │
└────────────────────────────┬────────────────────────────┘
                             │ offline batches
                             ▼
┌─────────────────────────────────────────────────────────┐
│  TRAIN (GPU)                                            │
│  loss ≈ −gain + λ·risk + μ·turnover                     │
│  update LoRA_A (news→side) · LoRA_B (size/risk) · …     │
│  base weights FROZEN                                    │
└────────────────────────────┬────────────────────────────┘
                             │ publish adapter versions
                             ▼
┌─────────────────────────────────────────────────────────┐
│  INFERENCE AGENT                                        │
│  base LM (EN) + LoRA stack + goal prompt/head           │
│  → {side, confidence, rationale}                        │
│  → risk clamps → broker execute → log reward            │
└─────────────────────────────────────────────────────────┘

Layer 1 — Base model (English, small, sovereign)

Pick an open-weight instruct model in the 3B–14B class that you can run and fine-tune on your own GPU infrastructure. Requirements:

• Strong enough English to read headlines and emit strict JSON decisions.
• Small enough that LoRA training finishes overnight, not next quarter.
• Runnable under your digital sovereignty constraints—weights you hold, inference you meter, no silent vendor fine-print on the critical path.

The base is not the trader. It is the shared linguistic substrate. You freeze it so that every LoRA experiment starts from the same known English competence. That is the opposite of letting a frontier chat model cosplay a different vendor’s identity in a browser tab: the base identity is a file on disk with a hash, not a marketing string.

Layer 2 — Goal: maximize gains (with teeth)

“Maximize gains” is incomplete until you write the score. A production goal looks more like:

• Primary: change in equity (cash + mark-to-market holdings) in dibs.
• Penalties: drawdown, turnover, fee drag, concentration in one ticker, short inventory if shorts are allowed.
• Horizon: reward credited at fill and again at horizon marks (hours/days), not only at the click of buy.

That score is what APG-style desks already know in their bones: machines beat humans when the scoreboard is clear and the loop is closed. Chat models feel clever because the scoreboard is “did the user like the paragraph.” Different game.

Implement the goal two ways that reinforce each other:

1. Prompt/system goal at inference: every decision call restates the objective and risk limits.
2. Train objective offline: LoRA updates maximize the ledger score, not next-token likelihood alone. Preference or policy gradients over (headline, book, action) → later equity delta are enough to start; full deep RL can wait until the ledger is thick.

Layer 3 — LoRA plugins (the incremental part)

LoRA is how you get “incremental learning” without boiling the ocean. Each adapter is a small matrix pair injected into attention/MLP blocks. You can:

• Train only the adapter while the base stays frozen (stable English, lower catastrophic forgetting).
• Version and roll back adapters like software packages (news-v3, risk-v1).
• Stack or swap domain cards: politics wire reading, liquidity reaction, Dutch vs EN headlines, later TH/ZH if the family needs them.
• A/B on paper before any live dibs risk.

Suggested first adapters:

Adapter	Input	Output / job
lora-news-side	headline + symbol + last + position	buy / sell / skip + confidence + short rationale
lora-size-risk	confidence + book + fee + caps	quantity within hard clamps (or a multiplier the clamps still own)
lora-regime	recent vol, breadth, event tags	risk-on / risk-off prior that biases size, not identity

As data seeps in—PolitiCap fills, marks, news ids—you retrain the hot adapter more often than the cold ones. That is incremental learning in the engineering sense: competence grows in thin layers while the foundation stays put.

Layer 4 — Experience ledger (because we have no decades of data)

Without a ledger you are still guesttimating. With one, every trade becomes a supervised or preference row:

• State: symbol, last, tradeable flag, position, cash, equity, fee rate, thesis prior, news id/url, simple tape features (volume delta, print count).
• Action: side, quantity, decision engine (keyword / model / lora-version), rationale text.
• Reward: immediate fill economics + mark-to-market over fixed horizons + penalties.

Early on the ledger will be sparse. That is expected. Two mitigations that are not cheats:

1. Simulation: replay historical news against a paper book; still log the same schema.
2. Human preference pairs: desk labels “this headline should not have sized max” — small but high-signal for LoRA.

The civic market remains the ground truth when live; simulation only bootstraps density. PolitiCap’s job is to make politician value observable. The ledger’s job is to make that observability trainable.

Layer 5 — Outer train loop, inner act loop

Do not train on the hot path. Separate clocks:

• Inner (seconds–minutes): fetch news and quotes, run base+LoRA inference, clamp, execute or dry-run, append ledger.
• Outer (hours–days): batch ledger → GPU job → new LoRA artifact → eval on held-out days → promote or discard.

That split matches how serious AI engineering already runs coding agents and inference farms: session continuity and prompt cache on the interactive path; heavier training offline on multi-GPU boxes when the batch is ready. Token cost stays on inference; training cost stays on scheduled jobs you can meter.

What this is not

• Not a prediction market. PolitiCap is a political-capital / civic market with continuous ticker tape and dibs—not binary “will X win?” contracts.
• Not “the chat model is the fund.” Chat is a coder and a critic. The trader is a versioned stack with a ledger.
• Not guaranteed alpha. Thin markets overfit. Adapters can memorize one Battle-of-the-AIs week. Risk clamps and halt switches are part of the architecture, not optional morals.
• Not full online backprop through the base. If you eventually need deeper updates, do them as rare base refreshes with eval gates—not as every fill mutates the foundation.

Why this could still matter

If the only systems that “learn trading” need thirty years of liquid tape, political capital stays a guestimate forever. A LoRA-pluggable, goal-conditioned stack lowers the data bar: you invent a market so value can be discovered, you log every discovery, and you let thin adapters climb the scoreboard while English (and later other languages) stay frozen and inspectable.

That is the parallel track: PolitiCap as the instrument; the goal-base-LoRA stack as the learner; DutchBud as the fintech spine where virtual credits, digital wallet behavior, and closed-loop ledger money already live in the 3DN family. Open banking and neobank narratives are how outsiders find the bank; the civic tape is how political capital becomes a number a machine can optimize.

Frontier continual learning will keep moving. You do not need to wait for it to start. You need a base that speaks, a goal that scores, adapters that plug in, a ledger that never lies about P&L, and enough GPU compute to retrain when the seepage of data justifies another card in the chassis.

3DN — compute, agents, and the family stack behind work · money · politics. Architecture first; scoreboard second; hype never.