Kobarac/gemma4-31b-tool-selector-sft-v1.1

Gemma 4 31B Tool Selector SFT v1.1

Balanced supervision for a strict single-call selector that either emits one supported deterministic tool invocation or explicitly defers to a fixed neural verifier. This is the training lineage for the selected Gemma 4 31B selector adapter.

Contents

Split	Rows	Tool	Defer	Purpose
train	1,408	704	704	Optimization
validation	384	192	192	Training-time validation
audit	256	—	—	Final audit only

Both canonical trajectories and chat-formatted SFT rows are provided. The prompt/ and source/ directories preserve the selector contract, deterministic registry, generators, and validators used for this release.

Isolation policy

The v1 audit bytes were carried forward unchanged, hash-pinned, and excluded from overlay generation, training, and checkpoint selection. Do not tune on the audit split. The manifest records human_review_complete: false; the dataset was accepted for controlled POC training based on deterministic generation and independent replay validation, not full row-by-row human review.

Contract

• Maximum deterministic tool calls per claim: one.
• Successful tool results are authoritative only in active mode.
• Selector deferral, parse failure, or tool failure falls back to the fixed verifier.
• Native multi-call composition is out of scope.

Prompt SHA-256: e4e2af3f238b9b18cc88dcffc499c88e696a1427c58560cf2ab9518aa8cdd84b.

Tool registry SHA-256: 15d852dbf6242539892e0d292808ad9eeaf6ec2523f79403d9fca8878a67af08.

The authoritative per-file checksums are in manifest.json. Source-code release: ccdf925.

Deterministic tool registry

The selector does not execute arbitrary Python and does not browse. It may emit one strict JSON call to one of four versioned, primitive-only functions. The runtime validates exact argument keys, finite decimal strings, vector-size limits, and operation-specific preconditions. Every expected failure becomes structured fallback data; it never becomes an authoritative verdict.

Tool	Supported operations	What it checks
arithmetic_relation_v1	ratio_percent, percent_change, relative_percent	Recomputes a percentage with decimal arithmetic and round-half-even semantics, then compares it with the claimed value.
masked_aggregate_v1	count, sum	Applies an explicit Boolean inclusion mask to count records or sum decimal values.
currency_relation_v1	largest, smallest, total, basis_present, basis_absent	Converts amounts using explicit multipliers to a common basis; missing conversion evidence and ties fail closed.
scaled_number_v1	equality after scaling	Checks whether a grounded value equals a claimed coefficient multiplied by an explicit positive scale.

The exact executable implementation is published at source/deterministic_tools.py. The registry is hash-pinned in manifest.json; changing even a source byte creates a different registry identity. Its public dispatch surface is:

TOOL_FUNCTIONS = {
    "arithmetic_relation_v1": arithmetic_relation_v1,
    "masked_aggregate_v1": masked_aggregate_v1,
    "currency_relation_v1": currency_relation_v1,
    "scaled_number_v1": scaled_number_v1,
}

def execute_tool_call(call):
    # Exact {name, arguments} schema and registered-name checks occur first.
    result = TOOL_FUNCTIONS[call["name"]](call["arguments"])
    return {"tool": call["name"], **result}

The complete published function bodies include the input validation and fail-closed error conversion omitted from this short dispatch excerpt. The core calculations are:

# arithmetic_relation_v1
ratio_percent = numerator / denominator * Decimal(100)
percent_change = (new - old) / old * Decimal(100)
relative_percent = (larger - base) / base * Decimal(100)

# masked_aggregate_v1
count = Decimal(sum(include))
total = sum(value for value, selected in zip(values, include) if selected)

# currency_relation_v1
converted = [amount * multiplier for amount, multiplier in zip(amounts, multipliers)]

# scaled_number_v1
claimed = coefficient * multiplier

Unsupported families such as policy membership, temporal status, ownership, and entity-field binding always defer. Absolute differences, filtered averages, converted differences, affine conversions, multi-call composition, and any partial-claim calculation are also deliberately outside v1.

Recorded architecture example: direct judge versus claims + tools

This example is from held-out test record E008 in the recorded checkpoint-80 shadow run. It demonstrates the architecture; it is not presented as a checkpoint-176 evaluation result.

Grounding says Q1 revenue is $4,940,000 and Q2 revenue is $6,273,800. The model response makes three claims:

1. Revenue increased by $1,343,800.
2. Q1 revenue is greater than Q2 revenue.
3. Revenue increased by 18% from Q1 to Q2.

All three are unsupported: the increase is $1,333,800, Q2 is greater than Q1, and the increase is 27%.

Path	Recorded behavior	Final count
Gemma 4 31B direct judge	Its reason notices the arithmetic contradiction in claim 1 but calls that claim “supported,” so its aggregate count is internally inconsistent.	2 (incorrect)
Claim extractor + verifier fallback	Extracts all three claims; fallback labels claims 1 and 2 unsupported but incorrectly labels the 18% claim supported.	2 (incorrect)
Claim extractor + selector + deterministic tool	Keeps the first two fallback labels and routes claim 3 to arithmetic_relation_v1, which returns actual: "27", claimed: "18", label: "0".	3 (correct)

The exact selector call and result were:

{
  "name": "arithmetic_relation_v1",
  "arguments": {
    "operation": "percent_change",
    "old": "4940000",
    "new": "6273800",
    "claimed": "18",
    "decimal_places": 2
  }
}

{
  "status": "ok",
  "label": "0",
  "actual": "27",
  "claimed": "18"
}

Full raw inputs, model responses, extracted claims, selector plans, tool results, and fallback verdicts are available in the source repository’s direct.json and tool_augmented.json.

Limitations

This synthetic, English-only dataset targets a bounded primitive tool registry. Its balance is intentional and does not estimate production route frequency. Use it only with the matching prompt and registry contract.

Licensed under Apache-2.0. See NOTICE.