ECAI SBRM search is a deterministic indexing and retrieval system for structured financial statements. Unlike text search, SQL-bound reporting, or probabilistic vector models, ECAI encodes financial concepts deterministically, writes them into reproducible disk indexes, and returns exact postings for every query. The same data and logic always produce the same indexed state and the same search result, making the system audit-ready, replayable, and infrastructure-grade. IPFS provides immutable transport, but the core value is deterministic financial concept retrieval with zero probabilistic AI.

This document describes a deterministic financial indexing and search system built on ECAI.

The value proposition is simple:

• Deterministic indexing of structured financial statements (SBRM)
• Deterministic retrieval of financial concepts
• Reproducible execution
• Zero probabilistic AI

IPFS is only the transport layer.

The core value is the indexing model.

Financial statement search today is typically:

• Text search (imprecise)
• SQL queries (schema-bound and brittle)
• Vector search (probabilistic and non-reproducible)
• Or manually curated reports

These approaches either:

• Approximate results,
• Depend on fragile schemas,
• Or rely on probabilistic ranking.

None of them provide cryptographically reproducible retrieval.

In regulated financial environments, that is a serious limitation.

ECAI indexing is deterministic by design.

Each financial concept (e.g. mini:CashAndCashEquivalents):

1. Is encoded deterministically
2. Is written into disk segments deterministically
3. Produces exact postings lists
4. Returns exact document matches

There is:

• No ranking heuristic
• No embeddings
• No scoring model
• No probabilistic similarity

The same input always produces the same index. The same query always produces the same result.

ECAI SBRM search provides:

• Exact concept retrieval
• Replayable indexing
• Audit-ready determinism
• Infrastructure-level reproducibility

Query → Posting List → Document IDs → Exact Retrieval

Not:

Query → Model → Guess → Ranked approximation

For financial systems, compliance, and audit:

• Results must be explainable.
• Results must be reproducible.
• Results must be verifiable.

If the same feature CID and data CID are replayed, the same index and the same search result are produced.

That is operational determinism.

IPFS makes both:

• The indexing logic
• The financial data

immutable and content-addressed.

But the strategic value is not IPFS.

The strategic value is:

Deterministic ECAI indexing of structured financial data.

This workflow makes both:

1. The SBRM JSONL data
2. The DamageBDD feature file

content-addressed and immutable via IPFS.

Execution becomes:

Feature CID → Loaded → Executed Data CID → Loaded → Indexed Query → Deterministic Retrieval

No mutable scripts. No local feature dependency. Everything is hash-addressed.

—

SBRM JSONL ──> ipfs add ──> CID (data)
Feature file ──> ipfs add ──> CID (logic)

curl execute_feature(feature_cid, vars)
        ↓
DamageBDD:
  ipfs cat(feature_cid)
  parse feature
  ipfs cat(data_cid)
  ingest
  query disk index
        ↓
Deterministic result

The logic itself is immutable.

This is executable intelligence stored as content.

—

Example: ecai_{sbrmquery.feature}

Feature: Query SBRM index from IPFS-hosted feature

  Scenario: Ingest JSONL and query disk index
    Given I store "{{ipfs_jsonl_cid}}" in "ipfs_jsonl_cid"
    When I ingest the SBRM financial JSONL file from IPFS hash in "ipfs_jsonl_cid"

    Given I store "{{base_dir}}" in "ecai_base_dir"
    Given I open the ECAI disk search at base dir "ecai_base_dir" and store it in "idx"

    When I query the ECAI SBRM index in "idx" for "{{term}}" and store the results in "docs"

    Then I set response status to 200
    And I set response json to:
      """
      {
        "ok": true,
        "term": "{{term}}",
        "docs": {{docs}}
      }
      """

—

ipfs add -Q ecai_sbrm_query.feature

Output:

bafybeifeaturecid...

This is your immutable executable intelligence.

—

ipfs add -Q ./sbrm.jsonl

Output:

bafybeidatacid...

—

Now both logic and data are content-addressed.

FEATURE="$(ipfs add -Q ecai_sbrm_query.feature)" && \
DATA="$(ipfs add -Q ./sbrm.jsonl)" && \
curl -sS -X POST http://127.0.0.1:8080/execute_feature_from_ipfs \
  -H 'content-type: application/json' \
  -d "{\"feature_cid\":\"$FEATURE\",\"vars\":{\"ipfs_jsonl_cid\":\"$DATA\",\"term\":\"mini:CashAndCashEquivalents\"}}"

Optional:

... | jq

—

1. ipfs cat(feature_cid)
2. Parse feature text
3. Execute BDD steps
4. ipfs cat(data_cid)
5. Ingest via ecai_{sbrmfinancialstatementingestor}
6. Query via ecai_disksearch
7. Return JSON

The logic is immutable. The data is immutable. The result is deterministic.

—

This model gives you:

• Portable executable intelligence
• Immutable logic
• Immutable data
• Deterministic indexing
• Deterministic retrieval
• Zero probabilistic AI

You are not calling a model.

You are executing a content-addressed intelligence program.

—

• Pin feature CIDs
• Pin data CIDs
• Restrict execute_feature_from_ipfs endpoint
• Enforce base_dir whitelist
• Snapshot disk index regularly

—

Traditional AI:

Mutable model Mutable weights Opaque inference

ECAI:

Immutable logic (IPFS feature) Immutable data (IPFS JSONL) Deterministic indexing Deterministic retrieval

This is structured intelligence.

Not stochastic generation.

—

Workflow:

Feature CID + Data CID → Execute → Retrieve → Deterministic Result

ECAI does not guess.

It retrieves.