SnakeBatch × Excel

Charles Dana · Monce SAS · May 2026

A predictive layer for the spreadsheet. SAT classification, missing-data inference, lookalike audit — native cell formulas.

1. The pitch in one sentence

Excel ships =TREND, =FORECAST.LINEAR, =FORECAST.ETS. None of them touch text, mixed types, categories, or industrial vocabulary. SnakeBatch does. We add three formulas to Excel and the spreadsheet becomes a predictive workbench:

=PREDICT(train, target, test)
=PREDICT.CANDLE(train, target, test)
=FILL(table)
=AUDIT(train, target, test)
=POTENTIAL(table, target)

Train via snakebatch.aws.monce.ai. Model lives inside the .xlsx as a Custom XML Part. Predictions spill across rows the same way =FILTER does. The workbook becomes a self-contained ML artifact — email it, share it, the model goes with it.

2. Three problems Excel doesn't solve today

3. =FILL — missing data, magically

The cell view

↓ =FILL(A1:E5)

Under the hood

# For each column with blanks:
for col_with_blanks in table:
    train = rows_where(col_with_blanks is not blank)
    test  = rows_where(col_with_blanks is blank)
    snake = Snake(train, target_index=col_with_blanks)   # 1.8s for 891 rows
    fill[col_with_blanks] = [snake.get_prediction(r) for r in test]

One Snake per column with blanks, all trained in parallel on Lambda. A 5-column / 1000-row table with 3 sparse columns → 3 Lambdas fire concurrently → ~2s wall clock.

4. =PREDICT — train / target / test

' Excel cell:
=PREDICT(A1:E120, "Délai", G1:K30)     → spills 30 predictions down L
=PREDICT.PROB(A1:E120, "Délai", G1:K30) → spills 30 × |classes| matrix
=PREDICT.TOP(A1:E120, "Délai", G1:K30, 3) → top-3 candidates per row

Datatype handling — the test-trickier-than-train problem

Real spreadsheets are messy. Train says "5j", test says "5 jours". Train says 120, test says "120,00". Train says "LGB", test says "LGB Menuiserie SAS". SnakeBatch handles this in two layers:

5. =AUDIT — the killer feature

The cell view

Three audit modes

Why the (c)/(n) split matters

Snake v5+ labels every lookalike as core (c) — routed to the bucket by SAT condition — or noise (n) — randomly injected for regularization. The audit cell can show both, with origin tags. Core lookalikes answer "what does the rule say?". Noise lookalikes answer "what does the broader population say?". Two independent signals on the same prediction.

6. =PREDICT.CANDLE — regression as a financial candle

The mapping — (c)/(n) becomes body/wick

The candle tells you what the model knows: the body is the specificity premium (c minus n), the wicks are the residual uncertainty across all 30+ peers. A tall body + short wicks = strong, narrow signal. A short body + long wicks = weak signal, hedge the decision.

The cell view — predicting "Prix" in euros

Row 47: SAT specificity adds +1,620€ over baseline → tall green candle, narrow wicks. Row 48: tiny body, almost a doji → standard pricing, no surprises. Row 49: SAT pulls -1,310€ below baseline → red candle — this client / article combination historically discounts.

The formula family

' Single cell — spills 4 columns: Open | High | Low | Close
=PREDICT.CANDLE(train, "Prix", test_row)

' Spilled across many test rows — (n × 4) array, drop straight into Excel Stock chart
=PREDICT.CANDLE(train, "Prix", G1:K30)

' One-cell glyph — Unicode candle, color-coded
=PREDICT.CANDLE.GLYPH(train, "Prix", test_row)     → △ / ▮ / ▽

' Distribution endpoint — spill all lookalike values for histogram / sparkline
=PREDICT.DIST(train, "Prix", test_row)             → spills [v1, v2, ..., vk]

' Confidence interval — alternative to candle when chart isn't needed
=PREDICT.CI(train, "Prix", test_row, 0.9)          → { mean, lo, hi }

Why this plugs into Excel natively

What the user does with it — three real workflows

1. Quote pricing. Candle's Low = floor (don't price below this without a discount approval). High = ceiling (above this, expect customer pushback). Body = negotiation room. The salesperson reads the candle and prices in seconds.
2. Lead-time risk. For =PREDICT.CANDLE(orders, "Délai", upcoming): a long-wick green candle means "expected fast, but tail risk". Order it early.
3. Anomaly screen. If the candle's color + body shape on a quote disagrees with what was just typed, flag for review. The model becomes a second pair of eyes on every line.

Why it's better than a confidence interval

7. =POTENTIAL — can this column even be predicted?

The cell view

' Excel cell:
=POTENTIAL(A1:E1000, "Délai")     → spills two cells: AUROC | Optimal accuracy

' Result spilled into B12:C12
AUROC: 0.91   |   Opt accuracy: 84% (threshold 0.55)

' Multi-target sweep — spill across rows
=POTENTIAL.SCAN(A1:E1000)            → one row per candidate target

' Result
Délai     0.91   84%   (predictable)
Prix      0.78   71%   (some signal)
Client    0.52   53%   (essentially random — don't bother)

Why this matters more than R²

The pitch in a phrase

=POTENTIAL is the data-quality probe. Before you trust =PREDICT, run =POTENTIAL. If AUROC < 0.6 the column doesn't have signal — no model will fix that.

Under the hood

# server-side, one Lambda call
def potential(table, target):
    train, test = stratified_split(table, target, ratio=0.8, seed=42)
    snake = Snake(train, target_index=target, mode="fast")
    probs = [snake.get_probability(r) for r in test]
    auroc = roc_auc(probs, test_labels)
    opt_acc, opt_thr = sweep_threshold(probs, test_labels)
    return {"auroc": auroc, "accuracy": opt_acc, "threshold": opt_thr}

Stratified split keeps class balance honest. Seeded for reproducibility — same workbook, same number, every time. fast mode (25 layers / bucket 16) is the right tradeoff: ~1s per call on snakebatch, AUROC within 1-2pp of full heavy mode.

8. Storing the model safely in the .xlsx

The .xlsx format is a zip of XML parts. There are three real places we can park a Snake model. Only one is built for it.

The Custom XML Part layout

┌─ workbook.xlsx (zip) ──────────────────────────────┐
│  /xl/worksheets/sheet1.xml         — user data     │
│  /xl/customXml/item1.xml           — model_stripped.json  │
│  /xl/customXml/itemProps1.xml      — schema id     │
│  /xl/customXml/_rels/item1.xml.rels                  │
│  /xl/_rels/workbook.xml.rels       — binds part     │
└────────────────────────────────────────────────────┘

Namespace: urn:monceai:snake:v1
Schema id: {ec2db94a-snake-monceai-2026}
Payload:   gzip+base64 of model_stripped.json   # 30-80% smaller than raw JSON
Header:    {"v":"5.4.5", "id":"v6-...", "sha256":"...", "trained_at":"..."}

Safety properties — what we get for free, what we add

The cloud fallback — never break the cell

def predict_cell(test_row):
    model = read_custom_xml_part("monceai-snake-model")
    if model and verify_sha256(model):
        return evaluate_local(model, test_row)        # instant, offline
    if model_id in workbook_metadata:
        return snakebatch_predict(model_id, test_row)   # cloud, ~150ms
    return "#NO_MODEL"

Three layers of safety: local first (fast, offline), cloud fallback (the model_id is also stored as a workbook custom property, so even if the embedded JSON is wiped we can re-fetch), graceful failure (#NO_MODEL instead of #REF! — tells the user to retrain).

9. Billing — tokens, the equation, the spec

8.1 The token equation

One token = $0.00001 of underlying AWS cost (compute + storage + requests). Sale price: $0.00005 / token — a flat 5× markup. Bulk pack: $50 / 1M tokens.

# Authoritative cost-to-tokens function. Lives in api/billing.py.
# Constants from /economics: ARM64 Graviton2, eu-west-3, April 2026.
GB_SEC     = 0.0000166667     # Lambda 10GB-class compute, $/GB·s
INVOKE     = 0.0000002        # Lambda request, $/invoke
S3_GBMO    = 0.023             # S3 standard, $/GB·month
S3_PUT     = 0.000005         # S3 PUT, $/op
S3_GET     = 0.0000004        # S3 GET, $/op
DDB_RW     = 0.00000125       # DynamoDB on-demand write, $/op

TOKEN_USD  = 0.00001          # 1 token = $0.00001 AWS cost (cost basis)
SELL_USD   = 0.00005          # 1 token sold for $0.00005 (5× markup)

def tokens_for(call):
    aws = (
        call.lambda_gb_seconds * GB_SEC
      + call.lambda_invokes    * INVOKE
      + call.s3_mb_month * 1e-3 * S3_GBMO
      + call.s3_puts           * S3_PUT
      + call.s3_gets           * S3_GET
      + call.ddb_writes        * DDB_RW
    )
    return math.ceil(aws / TOKEN_USD)        # round UP — never under-charge

8.2 What things actually cost, in tokens

* The 1-token ceil() floor on inference creates a small over-charge on tiny calls — intentional, prevents abuse via spam-clicking. At 71× markup on individual cells but 5× in any realistic batch, the average user pays the headline 5× rate.

8.3 The 150K-token starter pack

cdana@monce.ai gets 150,000 tokens on signup. That maps to $1.50 of AWS cost, sells for $7.50. Concretely it allows:

Generous enough for evaluation, finite enough that we know who's serious. Starter pack is one-time. Refills are paid (or paid-in-credit for design partners).

8.4 Per-call response — the workbook sees both axes

# Every snakebatch endpoint returns this envelope.
{
  "result": ...,
  "usage": {
    "lambda_calls": 17,
    "lambda_gb_seconds": 81.2,
    "s3_puts": 2, "s3_gets": 0,
    "ddb_writes": 1,
    "cost_usd": 0.0247,
    "tokens": 2470,
    "endpoint": "/v6/train",
    "model_id": "v6-fa9e3-...",
    "user_email": "cdana@monce.ai"
  },
  "balance": { "tokens": 147530, "refills_at": "2026-06-01" }
}

8.5 The workbook usage panel

10. Secure Lambda design — auth, balance, S3 metering

9.1 New AWS resources (all in eu-west-3, account 202533543033)

9.2 snake-batch-users schema

{
  "email":           "cdana@monce.ai",                    # PK
  "api_key":         "sk-snake-cdana-7Y3bF...4qV",         # 32 random bytes b58
  "api_key_sha256":  "a3f9...b1",                          # indexed, key never stored raw
  "balance_tokens":  150000,                              # NUMBER, atomic decrement
  "monthly_grant":   0,                                   # refill on 1st of month
  "created_at":      "2026-05-17T...",
  "status":          "active",                             # active | suspended | revoked
  "tier":            "design_partner",                     # maps to markup & cap
  "workbook_ids":    [...],                                # SHA-256 of customXmlPart sha
  "models_owned":    ["v6-fa9e3-..."],                    # for storage charging
  "last_call_at":    "2026-05-17T...",
  "daily_call_count": 0                                  # reset by meter Lambda
}

The raw api_key is shown to the user once at issuance, never read back. We store SHA-256 of it as a GSI — on every request we hash the bearer token, look up the user, decrement, log. Same pattern as Stripe / GitHub PAT.

9.3 Atomic balance decrement

# In api/handler.py, BEFORE invoking the worker Lambda:
def charge(api_key_hash, tokens):
    try:
        users.update_item(
            Key={"email": lookup_email(api_key_hash)},
            UpdateExpression="SET balance_tokens = balance_tokens - :t, "
                              "last_call_at = :now",
            ConditionExpression="balance_tokens >= :t AND #s = :a",
            ExpressionAttributeNames={"#s": "status"},
            ExpressionAttributeValues={":t": tokens, ":a": "active",
                                       ":now": now()},
        )
    except ConditionalCheckFailed:
        raise HTTP402("Insufficient tokens or account suspended")

Atomic via DDB ConditionExpression — no race, no double-charge. Pre-charge happens BEFORE the worker fires; if the worker over-runs the estimate, we charge the difference at completion. If the worker under-runs (rare), we credit the difference back. Estimates from /estimate are deliberately ~10% conservative so users don't 402 mid-job.

9.4 The auth flow — magic link, no password

║ Excel cell types =PREDICT(...) for the first time
║
║  add-in checks workbook custom property "monceai-api-key" — absent
║
║  call POST /v6/train without Authorization → 401 + www-auth-hint
║
║  add-in opens taskpane: "Sign in to monceai"
║       email field → cdana@monce.ai
║       submit → POST /auth/signup
║
║  snake-batch-auth Lambda:
║       1. validate email format + DNS MX
║       2. generate link_token = secrets.token_urlsafe(32)
║       3. write users[email].magic_link = sha256(link_token), expires=now+10min
║       4. SES send magic link → https://excel.aws.monce.ai/verify?t=<link_token>
║
║  user clicks link → GET /auth/verify?t=...
║       1. lookup users by hash(link_token), check expiry
║       2. if first-time: issue api_key, set balance_tokens=150000
║       3. respond with HTML page: "Return to Excel and click Continue"
║       4. add-in polls /auth/poll?email=... every 2s
║
║  add-in receives api_key, writes it to:
║       - workbook customXmlPart monceai-api-key  (per-workbook)
║       - Excel registry HKCU\Software\Monce\monceai\api_key  (Win, per-user)
║       - Mac: ~/Library/Containers/com.microsoft.Excel/.../monceai-key.json
║
║  =PREDICT retries with Authorization: Bearer sk-snake-... → result

9.5 Why magic-link, not OAuth, not password

9.6 S3 model storage — metered daily

Every model trained gets written to s3://snake-batch-monce/jobs/<hash(email)>/<model_id>/model_stripped.json. The user-prefix is required for IAM — the api Lambda only has s3:GetObject on the user's own prefix.

# snake-batch-meter Lambda — daily cron 00:30 UTC
def handler(event, ctx):
    for user in users.scan():
        prefix = f"jobs/{sha256(user.email)}/"
        total_bytes = sum(o.size for o in s3.list(prefix))
        mb_day = total_bytes / 1e6 / 30          # 1/30th of monthly cost per day
        tokens = math.ceil(mb_day * 23 / 10)        # 1 MB·day = 0.77 tokens
        charge(user.api_key_hash, tokens, kind="storage")
        log_storage_metering(user, total_bytes, tokens)

Storage is cheap — ~1 token per MB·day. 50 stored models at 200KB = 10MB × 30 days = ~230 tokens / month. Visible to the user via =ASK_BALANCE() (an Excel formula that hits /auth/balance) and on excel.aws.monce.ai/account.

9.7 Security hardening, declared upfront

9.8 Where this code lives

lambda_functions/
  api/handler.py            # existing — ADD: charge() inline, /v6/train wraps in try/charge
  auth/handler.py           # NEW — signup, verify, poll, rotate, balance
  billing/handler.py        # NEW — tokens_for(), charge(), refund()  (importable layer)
  meter/handler.py          # NEW — daily S3 scan, storage charging
terraform/
  auth.tf                   # NEW — users + keys tables, auth + meter Lambdas, SES domain
  iam.tf                    # NEW — per-user S3 prefix policies, billing Lambda invoke perms

excel-addin/
  taskpane/auth.html        # email entry, polling, key persistence
  functions.js              # adds Authorization header on every fetch

9.9 Provisioning cdana@monce.ai — the first record

When the auth Lambda is live, the bootstrap call is a single CLI:

aws dynamodb put-item --region eu-west-3 --table-name snake-batch-users \
  --item '{
    "email":          {"S": "cdana@monce.ai"},
    "api_key_sha256": {"S": "<sha256 of generated key>"},
    "balance_tokens": {"N": "150000"},
    "monthly_grant":  {"N": "0"},
    "tier":           {"S": "design_partner"},
    "status":         {"S": "active"},
    "created_at":     {"S": "2026-05-17"}
  }'

# Generated key (printed once, then discarded server-side):
# sk-snake-cdana-<32 random base58 chars>

The key is shown once, the SHA-256 lives in the table, and cdana@monce.ai signs in to the Excel add-in with email + the magic-link flow. Starter pack of 150,000 tokens (= $7.50 face / $1.50 AWS cost) covers a thorough evaluation. This row is not provisioned today — designed only.

11. The seamless install — one click on any Excel device

The chosen path: Office Add-in (Custom Functions)

VBA .xlam is Windows-only and triggers IT alerts. Office Add-ins via the Custom Functions API are the only mechanism Microsoft supports across Windows desktop, Mac desktop, and Excel for the web. They install from a manifest URL or AppSource, sandbox in their own runtime, and register first-class functions with IntelliSense and async support.

The 3-step install

What's behind the click

# 1. The user lands on https://monce.ai/excel
#    → serves a tiny page with three buttons: Windows / Mac / Web

# 2. Windows / Mac — the page redirects to:
ms-excel:ofe|u|https://excel.aws.monce.ai/manifest.xml
#    Excel auto-launches and shows the "Trust" dialog

# 3. Excel on the web — the page calls:
Office.context.requirements.isSetSupported("CustomFunctionsRuntime", "1.4")
#    and sideloads the manifest via Insert → Add-ins → Upload My Add-in

# 4. The manifest declares:
<CustomFunctions>
  <Function>
    <Name>PREDICT</Name>
    <Description>Snake classification on a train/test range</Description>
    <Parameters> ... </Parameters>
    <Result><Type>matrix</Type><Dimensionality>matrix</Dimensionality></Result>
  </Function>
  <!-- POTENTIAL, FILL, AUDIT same shape -->
</CustomFunctions>

What ships with the manifest

Total payload: ~75 KB. Hosted as static files on the same EC2. Excel updates them automatically on every workbook open (HTTP HEAD revalidation) — users never download a new version manually. We ship a fix at 10 AM, every workbook in the field uses it by 10:01.

The seamless paths, ranked

The "open in Excel" deep link, written out

# Windows + Mac Excel
<a href="ms-excel:ofe|u|https://excel.aws.monce.ai/manifest.xml">
  Install monceai for Excel
</a>

# Excel on the web
<a href="https://excel.officeapps.live.com/x/_layouts/16/AddIn.aspx?manifestUrl=https://excel.aws.monce.ai/manifest.xml">
  Install monceai for Excel Online
</a>

# Detection — one button, three OSes
if navigator.userAgent.includes("Mac") || navigator.userAgent.includes("Windows"):
    redirect_to("ms-excel:ofe|u|...")
else:
    redirect_to("https://excel.officeapps.live.com/...")

Backup paths, declared upfront

• VBA .xlam for users on Excel 2016/2019 without Office Add-in support — same backend, downloadable as a fallback. ~80 KB.
• Python in Excel (M365 cloud Python) — can call snakebatch directly via requests. We ship a snippet at excel.aws.monce.ai/python.txt the user pastes once.
• Office Scripts (TypeScript) for Excel-on-the-web users who want to script around the add-in.

12. The pitch to Mathieu

13. What we'd build first

14. The line that ties it all together

"Excel has =TREND for what's linear and =FORECAST.ETS for what's seasonal.
SnakeBatch gives Excel =PREDICT, =FILL and =AUDIT — for everything else."