LLM Post-Training for Vertical Domains: Multi-Domain Reinforcement Learning, Hallucination Control, and Verifiable Outputs in Finance and 3D Modeling

    A practical guide to post-training large language models for professional workflows. It explains why the bottleneck in domains like financial analysis and 3D modeling is reliability rather than knowledge, breaks down a multi-domain joint reinforcement learning pipeline with layered reward design, and details hallucination suppression through evidence traceability, structured output contracts, and validation loops. It includes pseudocode for the training pipeline, the mixed reward function, a financial output schema with validation logic, and a 3D build-and-verify loop, plus a three-layer evaluation framework for deciding whether a post-training investment is worth it.

    Introduction: In Professional Scenarios, the Bottleneck Is No Longer “Knowing,” but “Reliability”

    Over the past few years, most gains in LLM capability have come from pre-training: scaling data, refining architecture, and adding compute have substantially improved general knowledge and language ability. But when LLMs move into professional settings such as financial analysis, 3D modeling, legal review, and cybersecurity, the real bottleneck is often not whether the model “understands,” but whether it can be “trusted.” Can a financial analysis conclusion be traced back to the original disclosure? Can a generated 3D model place parts correctly at the specified dimensions? In multi-turn autonomous tasks, can the model self-correct when it fails?

    These questions share a common thread: correctness cannot be guaranteed by answers that merely “read plausibly.” It depends on traceable evidence chains, executable validation loops, and long chains of reasoning across multiple tools and documents.

    A clear pattern has emerged among model developers: the base model stays largely unchanged, and most new compute goes into the post-training stage, targeting several professional domains in a focused way. This approach is worth unpacking: why does it work, where are its limits, and why are finance and 3D modeling repeatedly chosen as focus areas? The following sections move from technical principles to engineering practice.


    Part 1: Where Post-Training Fits: From “Fluent Generation” to “Verifiable Tasks”

    1.1 Two Stages of Capability Acquisition

    LLM capability develops in roughly three stages:

    Stage Core Objective Main Approach Typical Output
    Pre-training Learn language and world knowledge Large-scale self-supervised learning General base capability
    Supervised fine-tuning (SFT) Align instruction format and task patterns High-quality demonstration data Usability, stability
    Reinforcement learning (RL) Optimize behavior policy under verifiable objectives Reward function + policy optimization Task success rate, reliability

    Post-training mainly refers to the latter two stages. Its value is not in “injecting new knowledge,” but in compressing the base model’s existing capabilities into a specific task distribution and constraint set, so outputs shift from “average-plausible” to “reliably correct.” This distinction matters: if the base model lacks a piece of knowledge, post-training can only improve the reliability of recalling what it already knows—it cannot create knowledge from nothing.

    1.2 Why “Adding Post-Training Compute” Is a Reasonable Choice

    The cost and cycle of pre-training make it unsuitable for frequent iteration: data cleaning, training schedules, and compute budgets can rarely support quarterly updates. By comparison, post-training offers:

    • High sample efficiency: hundreds of thousands to a few million high-quality annotations can noticeably change behavior on a specific task;
    • Short iteration cycle: updates can ship on a business cadence while the base model stays fixed;
    • Controllable risk: with the base model unchanged, rollback and canary strategies are clearer;
    • Composable scenarios: a single base model can spawn multiple industry-specific versions.

    1.3 Three Key Levers of Post-Training

    What actually determines the ceiling of post-training is three design factors:

    ① Coverage of verifiable rewards. RL needs reward signals. In coding tasks, whether code passes unit tests or runs at all is a naturally verifiable reward; in financial analysis, numerical consistency, citation traceability, and computational reproducibility can also be formalized as verifiable signals. The richer the verifiable rewards, the more efficient the post-training.

    ② Cross-domain task distribution. Multi-domain joint training is not simply stacking data; it lets the model share a “reasoning skeleton” across tasks. For example, the multi-step numerical reasoning needed for financial modeling and the spatial reasoning plus code-execution verification needed for 3D modeling are highly isomorphic in their “decompose—execute—verify” loop.

    ③ Strictness of the output contract. When output must follow a fixed structure (fields, units, citation IDs, confidence), the training objective shifts from a vague “answer well” to a concrete “valid format and verifiable content.”


    Part 2: Multi-Domain Joint Reinforcement Learning: Training Framework and Engineering

    2.1 Basic Structure of the Training Pipeline

    1. # Illustrative pseudocode: training pipeline for multi-domain joint RL
    2. def train_pipeline(base_model, tasks, stages):
    3. # Stage 1: general instruction alignment to establish baseline usability
    4. for batch in tasks.mix(sample="instruction"):
    5. base_model.sft_step(batch)
    6. # Stage 2: per-domain cold start, stabilizing behavior with a small set of high-quality demos
    7. for domain in ("code", "finance", "spatial_3d", "general"):
    8. for demo in tasks[domain].samples(n=2000, quality="high"):
    9. base_model.sft_step(demo)
    10. # Stage 3: joint RL, sharing policy parameters, computing verifiable rewards per task
    11. for step in range(stages.rl_steps):
    12. batch = tasks.mix(ratio=stages.ratio) # domain mix and curriculum sampling
    13. for sample in batch:
    14. response = base_model.generate(sample.prompt)
    15. score = reward(sample, response) # see section 2.2
    16. base_model.update(sample, response, score)
    17. return base_model

    Three easily overlooked engineering details in this structure:

    • The mix is not static. Early stages usually need a higher proportion of general tasks to keep base capabilities stable, while later stages gradually increase the share of high-value domains to avoid catastrophic forgetting;
    • Curriculum order matters. Building stable formatting and reasoning patterns with simple samples first, then introducing long-chain, multi-tool tasks, significantly reduces early policy collapse;
    • General-capability regression testing must run throughout. Running a general evaluation set every few steps is the only reliable way to catch silent degradation such as “domain skill rising while general ability falls.”

    2.2 Layered Reward Function Design

    1. # Illustrative pseudocode: mixed multi-task reward
    2. def reward(sample, response):
    3. r = 0.0
    4. # ① Verifiable reward: correctness signals that can be judged automatically, highest weight
    5. if sample.type in ("code", "math"):
    6. r += 1.0 * verify_by_tests(sample, response) # unit tests / numerical comparison
    7. # ② Process reward: are reasoning steps valid, or does it take shortcuts
    8. r += 0.3 * check_reasoning_steps(sample, response)
    9. # ③ Constraint reward: format, units, citation completeness
    10. r += 0.2 * check_contract(sample, response)
    11. # ④ Preference reward: model self-evaluation or a human preference model, covering open tasks hard to judge automatically
    12. r += 0.2 * preference_model(sample, response)
    13. # ⑤ Penalties: hallucination (unsupported claims), overconfidence, redundancy
    14. r -= 0.5 * hallucination_penalty(sample, response)
    15. r -= 0.1 * overconfidence_penalty(sample, response)
    16. return r

    The point of layered design: verifiable rewards provide the “anchor,” preference rewards provide “style and common sense,” and penalties provide “safety boundaries.” Relying only on a preference model tends to slide toward “sycophantic output”; relying only on verifiable rewards can make the model degrade into mechanically applying templates on open tasks.

    2.3 Three Common Risks and Mitigations

    1. Reward hacking. The model looks for scoring loopholes instead of genuinely improving, for example using verbose restatement to win keyword-matching points. Mitigations: add length and redundancy penalties to the reward, periodically spot-check high-scoring samples manually, and design multiple equivalent scoring standards for the same task to cross-validate.
    2. Catastrophic forgetting. Over-optimizing on vertical data can damage general capabilities. Mitigations: retain general-data replay, apply moderate regularization to base parameters, and monitor the regression curve on general evaluation sets.
    3. Training instability from sparse rewards. Long-chain tasks often have only the final result judgeable, with no signal in intermediate steps. Mitigations: introduce process rewards, break long tasks into independently verifiable subtasks, and do preference-contrastive learning on failed trajectories.

    Part 3: Financial Workflows: Turning “Hallucination” into a Measurable, Governable Metric

    Finance is a common priority for optimization for a straightforward reason: the tasks have long chains, low error tolerance, and naturally verifiable correct answers. Whether an analysis conclusion holds can ultimately be checked against disclosure documents, financial models, and accounting standards. This “verifiability” makes it the best testbed for measuring post-training effectiveness.

    3.1 Breaking Down Three Core Capabilities

    (1) Cross-document verification. Real financial analysis rarely relies on a single document. Prospectuses, annual reports, quarterly reports, announcements, and research reports must be cross-checked: are the same metrics defined consistently across documents? Do footnote disclosures support the body text? Do opening and closing figures reconcile? These tasks require the model to have a complete “retrieve—locate—compare—judge” chain, not a single-point extraction.

    (2) Financial modeling. The difficulty of modeling lies not in writing formulas but in the reasonableness of assumptions, consistency of definitions, and reproducibility of results. The goal of post-training should be to make the model a modeling assistant that “can calculate, can explain, and can self-check”: sourcing each assumption, keeping units consistent throughout calculation, and providing interval analysis for sensitivity.

    (3) Traceable research. This is the key mechanism for reducing hallucination. The model is required to provide evidence locations alongside its conclusions:

    1. # Illustrative: structured output contract for financial analysis (pseudocode; actual implementation depends on the tech stack)
    2. CONTRACT = {
    3. "type": "object",
    4. "required": ["answer", "evidence", "confidence"],
    5. "properties": {
    6. "answer": {"type": "string", "description": "Conclusion summary"},
    7. "evidence": {
    8. "type": "array",
    9. "items": {
    10. "type": "object",
    11. "required": ["doc_id", "locator", "quote"],
    12. "properties": {
    13. "doc_id": {"type": "string"}, # unique document identifier
    14. "locator": {"type": "string"}, # page/paragraph/table location
    15. "quote": {"type": "string"} # original excerpt for human verification
    16. }
    17. }
    18. },
    19. "assumptions": {"type": "array", "items": {"type": "string"}},
    20. "confidence": {"type": "number", "minimum": 0, "maximum": 1}
    21. }
    22. }
    1. # Illustrative: output validation logic (pseudocode)
    2. def validate_financial_output(resp, source_docs):
    3. # 1) Contract validation: all fields present, types correct
    4. if not schema_valid(resp, CONTRACT):
    5. return {"ok": False, "reason": "contract_violation"}
    6. # 2) Evidence validation: each citation must be locatable to the corresponding span in the source
    7. for ev in resp["evidence"]:
    8. text = fetch_span(source_docs, ev["doc_id"], ev["locator"])
    9. if not fuzzy_match(text, ev["quote"]):
    10. return {"ok": False, "reason": "evidence_not_found"}
    11. # 3) Computation validation: can the numerical conclusion be recomputed from the given assumptions
    12. if not recompute_check(resp["answer"], resp["assumptions"]):
    13. return {"ok": False, "reason": "arithmetic_inconsistent"}
    14. return {"ok": True}

    3.2 How to Measure Hallucination Rate

    “Hallucination rate” is a metric that needs a strict definition; otherwise numbers cannot be compared across sources. In practice, at least four layers should be distinguished:

    Layer Definition Judgment Method
    Factual error Statement conflicts with the source document Manual or rule-based comparison
    Unsupported claim Has a conclusion but no evidence backing it Evidence coverage check
    Citation distortion Quotes the original but misrepresents its meaning Semantic consistency judgment
    Computation error Numerical derivation is incorrect Recomputation verification

    Publicly reported industry practice shows that targeted post-training for professional domains like finance can reduce hallucination-type problems by orders of magnitude—in internal enterprise evaluations, cases of hallucination rate dropping from over 20% to under 10% are not uncommon. It should be emphasized that such numbers depend heavily on evaluation-set design and judgment standards; discussing percentages detached from those standards is of limited meaning. What is more worth borrowing is the engineering practice: turning “hallucination” from a vague subjective impression into four types of automatically judgeable metrics, and incorporating them into both training rewards and online monitoring.

    3.3 The Real Change in Cost Structure

    The cost of financial scenarios should not be judged only by per-call price. Total cost of ownership (TCO) includes at least three parts:

    1. TCO = inference cost + human review cost + rework and correction cost

    The value from lower hallucination rates comes mainly in the latter two: less human review work and shorter rework chains. So when evaluating a professional model, “unit price comparison” is of limited meaning; “cost per completed task” is the more meaningful measure.


    Part 4: 3D Modeling: The Loop of Spatial Understanding, Code Generation, and Tool Calling

    4.1 Why 3D Is a Natural Post-Training Testbed

    3D tasks have three characteristics that make them ideal training targets: results can be verified by rendering, geometric relationships can be quantified, and the execution chain can be automated. After the model outputs a parametric modeling script, whether the rendered result has correct proportions, whether parts intersect, and whether dimensions meet constraints can all be judged directly through geometric computation. This “automatically verifiable” property is consistent with the unit-test logic of coding tasks.

    4.2 A Combination of Three Capabilities

    (1) Spatial inference from vision and text. The model needs to judge relative proportions, orientations, occlusion relationships, and assembly constraints between objects. This requires aligning large amounts of “image—3D description” paired data, not just language modeling.

    (2) Code-based modeling. Translating 3D intent into a parametric modeling script is currently the most reliable path. Compared with directly generating mesh data, scripts are readable, editable, reusable, and version-manageable.

    1. # Illustrative pseudocode: natural-language spec -> parametric modeling script -> render validation loop
    2. def build_scene(spec):
    3. # spec is a structured requirement: dimensions, materials, assembly relationships
    4. scene = Scene(unit="mm")
    5. # Main body: generate the base at the given dimensions
    6. base = scene.add(Box(size=spec["base_size"]), name="base")
    7. # Constraint-driven assembly: align the part to the specified datum face, not hardcoded coordinates
    8. part = scene.add(Cylinder(radius=spec["r"], height=spec["h"]))
    9. align(part, target=base.top_face, mode="center")
    10. # Interference detection: catch geometric conflicts at generation time
    11. if has_interference(part, base):
    12. return scene, {"ok": False, "reason": "interference"}
    13. # Dimension validation: compare against the target dimensions in the requirement
    14. if abs(scene.bbox_size() - spec["target_size"]) > spec["tolerance"]:
    15. return scene, {"ok": False, "reason": "dimension_mismatch"}
    16. return scene, {"ok": True}

    (3) Professional software invocation. After generating the script, it must be imported into professional modeling software to execute, render, and export. This stage requires the model to understand tool interfaces, parameter semantics, and failure-retry strategies—essentially a tool-calling capability, isomorphic to the function-calling mechanism in agent frameworks.

    4.3 The Key to the Training Loop: Feeding “Render Results” Back into the Reward

    The most effective approach to 3D post-training is to make the execution result itself the reward signal:

    • Geometric validity: whether bounding-box dimensions, volume, and part counts meet the requirement;
    • Assembly reasonableness: whether there are interferences, floating parts, or misalignment;
    • Visual consistency: similarity between the rendered image and the reference image (using a general image-similarity metric);
    • Editability: whether the script is structured and whether parameters are exposed as variables for later modification.

    Such rewards are naturally automatable, efficient for training, and hard to fool with rhetoric—because geometry does not lie.


    Part 5: Expanding the Scenarios: The General Logic from Finance and 3D to Professional Collaboration

    Notably, this trend is not limited to finance and 3D. Some developers have launched agent products for professional collaboration, building capabilities around vertical domains such as cybersecurity, legal, and finance, with commercialization moving faster than expected. Observing finance, 3D, and these domains together yields a general selection standard for professional post-training:

    1. Results are verifiable: there is a clear way to judge correctness (computations can be recomputed, geometry can be validated, code can be executed);
    2. Task chains are long: a single-turn conversation cannot finish them; they need multi-step reasoning and tool orchestration;
    3. Error tolerance is strict: the cost of errors is high, and customers are willing to pay for reliability;
    4. Knowledge-intensive but relatively stable: domain knowledge changes less frequently than the technical implementation, so the investment can be recovered sustainably.

    Scenarios meeting these four criteria usually have the highest post-training ROI. Conversely, if correctness depends on highly subjective judgment and lacks automatable verification, the marginal benefit of post-training decays quickly.


    Part 6: A Reusable Implementation Framework: How to Evaluate Whether a Post-Training Is Worth It

    6.1 Building a Three-Layer Evaluation System

    1. Layer 1: General capability regression — prevent specialization from damaging baseline abilities
    2. Layer 2: Domain capability evaluation — build an evaluation set from real business samples, covering long-tail scenarios
    3. Layer 3: End-to-end cost evaluation — factor in human review and rework, assessing total cost per task

    All three layers are necessary. Doing only Layer 1 misses the scenario gains; doing only Layer 2 risks exposing general degradation under real traffic; skipping Layer 3 makes it impossible to prove the investment’s value to business stakeholders.

    6.2 Four Points for Constructing the Evaluation Set

    • From real business: desensitized real tasks are better than hand-written illustrative problems;
    • Cover failure modes: deliberately include hard samples such as conflicting definitions, missing data, and cross-document contradictions;
    • Automatable judgment: prioritize task types that can be recomputed, executed, or compared;
    • Version management: the evaluation set itself should be under version control like code, to avoid being “accidentally optimized” during training.

    6.3 Continuous Governance After Launch

    • Monitor metrics: hallucination rate, evidence coverage rate, tool-call success rate, human intervention rate;
    • Feedback loop: human correction records flow back as training data, forming continuous iteration;
    • Canary strategy: validate professional-capability updates on low-risk traffic first, then gradually ramp up.

    Conclusion

    From this practice of “keeping the base model fixed and strengthening post-training,” three conclusions of broader relevance to developers and enterprise users can be drawn:

    First, post-training is an “efficiency tool,” not “capability magic.” It excels at stabilizing existing capabilities to a deliverable standard but cannot fill gaps in the base model’s knowledge. If the base model has systemic cognitive blind spots in a domain, consider data supplementation or retrieval augmentation first, rather than simply piling on more reinforcement training.

    Second, verifiability is the primary criterion for choosing vertical scenarios. Finance and 3D became focus areas essentially because their correctness can be judged by machines. For any professional post-training design, the first step should be to answer “how can this task automatically determine right from wrong.”

    Third, the value of a professional model should be measured by cost per completed task. Metrics that seem “soft,” such as hallucination rate, evidence traceability, and tool-call success rate, ultimately translate into human review hours and business risk exposure. Incorporating them into a measurable evaluation system is what gives professional post-training a clear business justification path.

    Post-training is moving LLMs from “general assistants” to “participants in professional workflows.” Understanding its capability boundaries and engineering essentials matters more than chasing single-point benchmark numbers—because what truly determines success in deployment is the model’s ability to deliver stable results across a real business chain.