# What Is the Cross-Validate Tool in AI Berkshire? A Complete Guide to Financial Data Validation

> Explore the AI Berkshire cross-validate tool. Automatically compare financial data across sources, flag discrepancies, and ensure accurate valuations with a consensus median.

- Repository: [Xbt Lin/ai-berkshire](https://github.com/xbtlin/ai-berkshire)
- Tags: how-to-guide
- Published: 2026-07-10

---

**The cross-validate tool in AI Berkshire automatically compares a single financial metric across multiple independent data sources, flags any provider that deviates beyond a configurable tolerance threshold, and produces a consensus median value to ensure downstream valuation models use rigorously verified figures.**

The cross-validate tool is a foundational utility within the **Financial Rigor Toolkit** ([`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py)) of the `xbtlin/ai-berkshire` repository. Designed to enforce data integrity before financial analysis begins, this tool prevents floating-point drift and source discrepancies from corrupting investment calculations. It serves as the critical validation layer invoked automatically when the Investment Team skill reaches the "financial rigor verification" step.

## How the Cross-Validate Algorithm Works

The validation process implemented in [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) follows a strict four-step pipeline to guarantee exact arithmetic and objective consensus building.

### Step 1: Exact Decimal Conversion

To eliminate floating-point precision errors common in financial calculations, the tool converts all input values to `Decimal` objects using the `exact()` function (lines 31–38). This ensures that subsequent deviation calculations remain mathematically precise without binary floating-point drift.

### Step 2: Median Reference Calculation

The algorithm calculates the **median** of all supplied values to establish an unbiased reference point (lines 78–81). Unlike a mean, the median is resistant to extreme outliers, making it the optimal consensus value when comparing data from disparate sources like annual reports versus third-party APIs.

### Step 3: Deviation Detection and Flagging

For each source, the tool computes the absolute percentage deviation from the median reference. If the deviation exceeds the tolerance percentage (default **2%**), the source is marked with a red ❌; otherwise, it receives a green ✅ (lines 86–92). This binary status allows automated workflows to immediately identify problematic data providers.

### Step 4: Consensus Output

The function returns a dictionary containing the consensus value (median) and a boolean `all_consistent` flag indicating whether every source fell within tolerance (lines 94–104). A concise table prints to stdout showing each source, its raw value, and deviation status for human review.

## Using the Cross-Validate Tool

The tool supports both command-line invocation for ad-hoc analysis and programmatic integration for automated research pipelines.

### Command-Line Interface

Invoke the `cross-validate` command directly from [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) to compare revenue figures from multiple providers:

```bash
python3 tools/financial_rigor.py cross-validate \
    --field revenue \
    --values '{"AnnualReport": 7518, "Yahoo": 7500, "StockAnalysis": 7520}' \
    --unit 亿 \
    --tolerance 2.0

```

This execution compares three independent revenue sources, allows a 2% variance, and outputs the consensus median (7518) while flagging Yahoo’s deviation.

### Programmatic Integration

Import the `cross_validate` function into Python scripts to validate data before valuation modeling:

```python
from tools.financial_rigor import cross_validate

field = "revenue"
source_vals = {
    "AnnualReport": 7518,
    "Yahoo": 7500,
    "StockAnalysis": 7520
}

result = cross_validate(
    field, 
    source_vals, 
    unit="亿", 
    tolerance_pct=2.0
)

print(result["consensus"])       # → 7518 (median)

print(result["all_consistent"])   # → False (Yahoo deviates >2%)

```

### Automated Workflow Validation

Integrate the tool into research pipelines to enforce hard stops on inconsistent data:

```python

# In a research pipeline after gathering data:

if not result["all_consistent"]:
    raise ValueError("Source discrepancy exceeds tolerance – abort valuation.")

# Continue with valuation using the consensus value

consensus_revenue = result["consensus"]

```

## Integration in AI Berkshire Workflows

The cross-validate tool operates as the **data integrity layer** within the broader AI Berkshire ecosystem. According to [`skills/investment-team.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-team.md) (lines 79–82), the Investment Team skill automatically invokes this tool during the "financial rigor verification" step. This automation ensures that all team agents validate financial figures across at least two independent providers before proceeding to valuation scenarios like `verify-valuation` or `three-scenario` analysis.

By surfacing discrepancies early in the workflow, the tool mitigates the risk of propagating erroneous figures into complex valuation models, aligning with the project's philosophy that all financial calculations must use exact `Decimal` arithmetic.

## Summary

- The cross-validate tool in AI Berkshire compares financial metrics from multiple sources using exact `Decimal` arithmetic to prevent floating-point errors.
- It calculates a median consensus value and flags any source deviating beyond the configurable tolerance (default 2%).
- Implemented in [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py), it returns a dictionary with `consensus` and `all_consistent` boolean for programmatic decision-making.
- The Investment Team skill automatically invokes this tool during financial rigor verification steps to ensure data integrity across all agent workflows.
- Both CLI and Python API interfaces are available for ad-hoc analysis and automated pipeline integration.

## Frequently Asked Questions

### What is the default tolerance for the cross-validate tool?

The default tolerance is **2%**, meaning any source value deviating more than 2% from the median consensus is flagged as inconsistent. Users can override this via the `--tolerance` CLI flag or `tolerance_pct` parameter in the Python API.

### How does the tool handle floating-point precision issues?

The tool eliminates floating-point drift by converting all inputs to `Decimal` objects using the `exact()` function (lines 31–38 of [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py)). This ensures that deviation calculations and median computations remain mathematically exact, which is critical for financial rigor.

### Can the cross-validate tool be used outside of the Investment Team workflow?

Yes. While the Investment Team skill automatically invokes the tool during the "financial rigor verification" step (lines 79–82 of [`skills/investment-team.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-team.md)), developers can import and call the `cross_validate()` function directly from any Python module or script within the repository for standalone validation tasks.

### What happens when a data source exceeds the tolerance threshold?

Sources exceeding the tolerance are marked with a ❌ status in the output table, and the `all_consistent` flag in the returned dictionary is set to `False`. This allows calling scripts to implement fail-safe logic, such as aborting valuation calculations or alerting analysts to investigate the specific data provider.