The spreadsheet engine for agentic products

Agents call spreadsheet operations directly instead of burning tokens generating code. Ready-made, familiar UI for when humans need to read or edit. Fast, rigorously tested, and quick to integrate.

Get started View docs

Humans

npm install @grid-is/spreadsheet-engine

Agents

Install GRID's spreadsheet skills:
npx -y skills add GRID-is/skills -g --all

Then create a React-based spreadsheet editor that uses GRID's packages for the heavy-lifting. Allow the user to drag-and-drop an .xlsx to open it, edit cells, and download an updated .xlsx file.

Built with an agent, on top of a spreadsheet

A coding agent built this on top of a financial analyst's Excel model. Drag the sliders and watch the GRID engine recalculate hundreds of cells in real time.

Property value

$900,000

Loan amount

$600,000

Interest rate

5.00%

Loan term

25 yr

Monthly payment

—

Down payment

—

Total interest

—

DebtEquityAnnual payment

Amortisation schedule

300 cells recalculated

Our products

The deterministic engine your agents need.
The familiar UI surfaces your users expect.

Spreadsheet Engine

Spreadsheet logic and calculations, running natively inside your application. Headless, fast, and fully compatible with Excel and Google Sheets out of the box.

Learn more

Spreadsheet ViewerA lightweight, themeable viewer for displaying spreadsheets beautifully inside your product.

Spreadsheet EditorA spreadsheet editor that feels at home in your product, scoped to the editing your users need.

Excel add-inYour own Excel add-in, superpowered by our deterministic engine and your own domain skills.

Your ownThe headless engine, integrated exactly the way you need it.Get started

Faster spreadsheet reasoning for LLM agents

The GRID engine lets LLMs work directly with spreadsheet models through simple tool calls, cutting latency, token usage, and complexity while returning accurate results faster.

PromptHow low does churn need to be so we reach $250k in annual recurring revenue?

GRID engine1.5s·86 tokens

I'll perform goal seek using the engine.

engine

goalSeek({ set: Assumptions!B7, target: Summary!B2 = $250k })

✓engine returned in one call

✓Churn needs to drop to 2.4% to reach $250k ARR.

Without GRID11.0s·3,240 tokens

I'll generate code to run goal seek.

ran goalseek.py120 / 120 lines

1import openpyxl
2import math
3from openpyxl.utils import get_column_letter, column_index_from_string
4from openpyxl.styles import NamedStyle, Font, Alignment, numbers
5from copy import copy
6 
7# ---- config -------------------------------------------------------
8SRC         = "arr_model.xlsx"
9TARGET_ARR  = 250_000
10CHURN_CELL  = "Assumptions!B7"
11ARR_CELL    = "Summary!B2"
12MONTHS      = 12
13MAX_ITERS   = 64
14TOL         = 1.0            # dollars
15 
16wb      = openpyxl.load_workbook(SRC, data_only=False)
17assum   = wb["Assumptions"]
18model   = wb["Model"]
19cohorts = wb["Cohorts"]
20summary = wb["Summary"]
21 
22def col(i):
23    return get_column_letter(i)
24 
25def num(cell):
26    v = cell.value
27    return float(v) if isinstance(v, (int, float)) else 0.0
28 
29# openpyxl never recalculates formulas, so every dependent cell that
30# touches churn has to be re-derived by hand for each candidate value.
31def set_churn(rate):
32    assum["B7"] = rate
33    for r in range(2, assum.max_row + 1):
34        if assum.cell(r, 1).value == "monthly_churn":
35            assum.cell(r, 2).value = rate
36 
37def retained(start_mrr, rate, months):
38    # geometric decay of one cohort's MRR across the window
39    total, mrr = 0.0, start_mrr
40    for _ in range(months):
41        total += mrr
42        mrr   *= (1.0 - rate)
43    return total
44 
45def recompute_cohorts(rate):
46    # rebuild the per-cohort waterfall on the Cohorts sheet
47    for r in range(2, cohorts.max_row + 1):
48        name = cohorts.cell(r, 1).value
49        if name is None:
50            continue
51        start = num(cohorts.cell(r, 2))
52        kept  = retained(start, rate, MONTHS)
53        cohorts.cell(r, 3).value = kept
54        cohorts.cell(r, 4).value = kept / MONTHS
55        mrr = start
56        for m in range(MONTHS):
57            cohorts.cell(r, 5 + m).value = mrr
58            mrr *= (1.0 - rate)
59 
60def recompute_model(rate):
61    # roll cohorts up into the monthly Model sheet
62    for m in range(MONTHS):
63        c, month_total = 3 + m, 0.0
64        for r in range(2, cohorts.max_row + 1):
65            month_total += num(cohorts.cell(r, 5 + m))
66        model.cell(2, c).value = month_total
67        model.cell(3, c).value = month_total * 12
68 
69def compute_arr(rate):
70    set_churn(rate)
71    recompute_cohorts(rate)
72    recompute_model(rate)
73    dec = 3 + (MONTHS - 1)
74    arr = num(model.cell(2, dec)) * 12
75    summary["B2"] = arr
76    return arr
77 
78# ---- goal seek: binary-search churn so ARR == TARGET_ARR ----------
79lo, hi = 0.0, 0.25
80best   = None
81arr_lo = compute_arr(lo)
82arr_hi = compute_arr(hi)
83assert arr_lo >= TARGET_ARR >= arr_hi, "target not bracketed"
84 
85for i in range(MAX_ITERS):
86    mid = (lo + hi) / 2.0
87    arr = compute_arr(mid)
88    if abs(arr - TARGET_ARR) <= TOL:
89        best = mid
90        break
91    if arr > TARGET_ARR:
92        lo = mid        # ARR too high -> churn can rise
93    else:
94        hi = mid        # ARR too low  -> churn must fall
95    best = mid
96 
97churn = round(best * 100, 2)
98 
99# ---- write the answer back & tidy formatting ----------------------
100summary["A4"] = "Max monthly churn for $250k ARR"
101summary["B4"] = best
102summary["B4"].number_format = "0.0%"
103summary["B2"].number_format = numbers.FORMAT_CURRENCY_USD_SIMPLE
104 
105pct = NamedStyle(name="pct", number_format="0.0%")
106for r in range(2, assum.max_row + 1):
107    if assum.cell(r, 1).value == "monthly_churn":
108        assum.cell(r, 2).style = pct
109 
110# re-apply column widths so the rebuilt sheets stay readable
111for ws in (cohorts, model, summary):
112    for c in range(1, ws.max_column + 1):
113        ws.column_dimensions[col(c)].width = 14
114 
115# sanity check before overwriting the source file
116final = compute_arr(best)
117assert abs(final - TARGET_ARR) <= max(TOL, TARGET_ARR * 0.001)
118 
119wb.save(SRC)
120print(f"max monthly churn = {churn}%  ->  ARR ${final:,.0f}")

✓Churn needs to drop to 2.4% to reach $250k ARR.

Prompt

GRID engine0.0s·0 tokens

I'll perform goal seek using the engine.

engine

goalSeek({ set: Assumptions!B7, target: Summary!B2 = $250k })

running goalseek()…

Without GRID0.0s·0 tokens

I'll generate code to run goal seek.

writing goalseek.py0 / 120 lines

Times and token counts are illustrative. Real results vary with the model, workbook, and task. The gap is sometimes smaller and often much larger.

The bridge between LLMs and spreadsheets

Spreadsheets are deceptively complex, and language models struggle to manipulate them accurately. To read or modify one, an LLM has to generate code each time, which is slow, costly in tokens, and failure-prone as complexity grows.

GRID gives your agent a structured interface to read cells, apply changes, and recalculate with a function call, not generated code. Results are deterministic, the same reliable recalculation as Excel and Google Sheets. The engine also enables LLMs to generate spreadsheets from scratch, accurately and at scale.

YOUR AGENT

structured operations

GRID ENGINE

reads, writes, function calls

SPREADSHEETSExcel, Google Sheets

Trusted by teams that can't afford to get it wrong

Major investment banks

An Excel add-in that generates and edits with confidence

Working with an AI platform used at major investment banks, we built an Excel add-in where the model runs domain-specific skills with the GRID engine instead of acting on Excel directly. The engine sandboxes the spreadsheet and catches errors before anything touches the file, so the model never corrupts an important document.

Explore the Excel add-in

Leading LLM provider

Spreadsheet logic the model can call directly

A leading LLM provider builds on GRID at the core of its spreadsheet capabilities. Instead of generating brittle code to read or modify a sheet, the model calls a structured interface backed by GRID's deterministic engine, which keeps spreadsheet-driven workflows reliable as they scale.

Learn about AI workflows

Get started now

Install the engine from npm with a free evaluation license and start building today. When you are ready to ship, talk to us. Most teams are surprised how quickly they go from first install to production, with direct support from the GRID team throughout.

Get started

Commercial licensing

1import openpyxl

2import math

3from openpyxl.utils import get_column_letter, column_index_from_string

4from openpyxl.styles import NamedStyle, Font, Alignment, numbers

5from copy import copy

7# ---- config -------------------------------------------------------

8SRC = "arr_model.xlsx"

9TARGET_ARR = 250_000

10CHURN_CELL = "Assumptions!B7"

11ARR_CELL = "Summary!B2"

12MONTHS = 12

13MAX_ITERS = 64

14TOL = 1.0 # dollars

16wb = openpyxl.load_workbook(SRC, data_only=False)

17assum = wb["Assumptions"]

18model = wb["Model"]

19cohorts = wb["Cohorts"]

20summary = wb["Summary"]

22def col(i):

23 return get_column_letter(i)

25def num(cell):

26 v = cell.value

27 return float(v) if isinstance(v, (int, float)) else 0.0

29# openpyxl never recalculates formulas, so every dependent cell that

30# touches churn has to be re-derived by hand for each candidate value.

31def set_churn(rate):

32 assum["B7"] = rate

33 for r in range(2, assum.max_row + 1):

34 if assum.cell(r, 1).value == "monthly_churn":

35 assum.cell(r, 2).value = rate

37def retained(start_mrr, rate, months):

38 # geometric decay of one cohort's MRR across the window

39 total, mrr = 0.0, start_mrr

40 for _ in range(months):

41 total += mrr

42 mrr *= (1.0 - rate)

43 return total

45def recompute_cohorts(rate):

46 # rebuild the per-cohort waterfall on the Cohorts sheet

47 for r in range(2, cohorts.max_row + 1):

48 name = cohorts.cell(r, 1).value

49 if name is None:

50 continue

51 start = num(cohorts.cell(r, 2))

52 kept = retained(start, rate, MONTHS)

53 cohorts.cell(r, 3).value = kept

54 cohorts.cell(r, 4).value = kept / MONTHS

55 mrr = start

56 for m in range(MONTHS):

57 cohorts.cell(r, 5 + m).value = mrr

58 mrr *= (1.0 - rate)

60def recompute_model(rate):

61 # roll cohorts up into the monthly Model sheet

62 for m in range(MONTHS):

63 c, month_total = 3 + m, 0.0

64 for r in range(2, cohorts.max_row + 1):

65 month_total += num(cohorts.cell(r, 5 + m))

66 model.cell(2, c).value = month_total

67 model.cell(3, c).value = month_total * 12

69def compute_arr(rate):

70 set_churn(rate)

71 recompute_cohorts(rate)

72 recompute_model(rate)

73 dec = 3 + (MONTHS - 1)

74 arr = num(model.cell(2, dec)) * 12

75 summary["B2"] = arr

76 return arr

78# ---- goal seek: binary-search churn so ARR == TARGET_ARR ----------

79lo, hi = 0.0, 0.25

80best = None

81arr_lo = compute_arr(lo)

82arr_hi = compute_arr(hi)

83assert arr_lo >= TARGET_ARR >= arr_hi, "target not bracketed"

85for i in range(MAX_ITERS):

86 mid = (lo + hi) / 2.0

87 arr = compute_arr(mid)

88 if abs(arr - TARGET_ARR) <= TOL:

89 best = mid

90 break

91 if arr > TARGET_ARR:

92 lo = mid # ARR too high -> churn can rise

93 else:

94 hi = mid # ARR too low -> churn must fall

95 best = mid

97churn = round(best * 100, 2)

99# ---- write the answer back & tidy formatting ----------------------

100summary["A4"] = "Max monthly churn for $250k ARR"

101summary["B4"] = best

102summary["B4"].number_format = "0.0%"

103summary["B2"].number_format = numbers.FORMAT_CURRENCY_USD_SIMPLE

104

105pct = NamedStyle(name="pct", number_format="0.0%")

106for r in range(2, assum.max_row + 1):

107 if assum.cell(r, 1).value == "monthly_churn":

108 assum.cell(r, 2).style = pct

109

110# re-apply column widths so the rebuilt sheets stay readable

111for ws in (cohorts, model, summary):

112 for c in range(1, ws.max_column + 1):

113 ws.column_dimensions[col(c)].width = 14

114

115# sanity check before overwriting the source file

116final = compute_arr(best)

117assert abs(final - TARGET_ARR) <= max(TOL, TARGET_ARR * 0.001)

118

119wb.save(SRC)

120print(f"max monthly churn = {churn}% -> ARR ${final:,.0f}")