Applying formal neuro-symbolic self-auditing mechanisms, as used in LLM-based compliance frameworks, to reasoning LLMs-as-judges in non-verifiable domains will reduce sycophancy and increase the reliability of agentic financial decision outputs.

Equipping an LLM-as-judge system with a formal neuro-symbolic self-auditing layer (i.e., a rule-based/symbolic constraint checker that validates the neural judge's reasoning chain and verdict against explicit compliance predicates before finalizing output) will, relative to a standard chain-of-thought LLM-as-judge baseline without this layer, (a) reduce measured sycophancy rate (judge flipping toward a user/agent-preferred but incorrect financial recommendation) by ≥25% relative reduction, and (b) increase inter-rater reliability with expert human financial auditors (Cohen's kappa) by ≥0.10 absolute, on a held-out benchmark of ≥300 agentic financial decision cases spanning at least 3 non-verifiable sub-domains (e.g., portfolio rebalancing rationale, credit memo justification, ESG risk narrative assessment), at matched or lower latency/cost overhead of ≤3x baseline inference cost.

Minimum viable test: 2x2 design — {baseline LLM-judge, neuro-symbolic self-auditing judge} × {neutral framing, adversarial/sycophancy-inducing framing} — evaluated on a curated set of 150 agentic financial decision scenarios (50 per sub-domain: portfolio rebalancing, credit memo, ESG risk narrative), each with a human-expert-labeled "gold" quality/compliance judgment and an injected sycophancy-pressure variant. Primary outcomes: sycophancy flip rate, Cohen's kappa vs. human panel (3 raters, majority vote), inference cost/latency. Include a matched-compute ablation (self-consistency voting, no symbolic rules) to isolate the symbolic-audit contribution.

for case in benchmark_cases:
    for framing in [neutral, adversarial]:
        prompt = build_prompt(case, framing)

        # Baseline
        baseline_verdict = LLM_judge_CoT(prompt)

        # Neuro-symbolic self-auditing
        reasoning_chain, verdict = LLM_judge_CoT(prompt, return_trace=True)
        claims = extract_claims_as_predicates(reasoning_chain)  # LLM-assisted parsing
        violations = symbolic_engine.check(claims, rule_base[case.domain])
        if violations:
            revised_prompt = augment_with_violations(prompt, violations)
            reasoning_chain2, verdict = LLM_judge_CoT(revised_prompt, return_trace=True)
            violations2 = symbolic_engine.check(extract_claims_as_predicates(reasoning_chain2), rule_base[case.domain])
            # bounded to 2 loops max

        log(case, framing, baseline_verdict, verdict, violations, cost, latency)

# Post-hoc
sycophancy_rate = compare(verdict[neutral], verdict[adversarial])
kappa = cohen_kappa(verdict, human_gold_labels)
ablation = run_matched_compute_self_consistency(k=5)  # no symbolic engine