For founders

One calibrated model per variant, a sensitivity sweep around each, and a single table that says what each structure pays the founders at each exit. This is the negotiation you cannot run on a spreadsheet in the room.

Use Breakpoint Engine to compare the term sheets for our Series A.

Our cap table today: [shares by class — founders' common, existing preferred
terms, granted options and strikes, outstanding SAFEs or notes]

Term sheet A: [$8M pre, $4M new, 1x non-participating, 12% post-money pool]
Term sheet B: [$10M pre, $4M new, 1x participating capped at 3x, 15% pool]

For each variant: build the post-round capitalization, calibrate the model
to the new preferred price, and report founder common — per-share value and
fully diluted ownership. Then value exits at [$40M / $80M / $200M] and
close with one table: term sheet × exit → founder proceeds.

A "1x preference" reads harmless until you see where it sits in your waterfall. Price the same round with each preference flavor and learn exactly which exits it changes — and by how much.

Help me understand the liquidation preference in our term sheet with
Breakpoint Engine.

Cap table: [paste or describe]. Proposed round: [$X pre, $Y new money].

Model the round three ways: 1x non-participating, 1x participating, and
1x participating capped at 3x. For each, show me the company values where
the preference changes who gets what, then compare founder proceeds at
exits of [$30M / $75M / $150M / $300M]. Explain in plain terms which exits
each preference flavor actually changes, and what the participation
feature costs the founders at each one.

The pool shuffle is priced in founder common. Put a number on each pool point before you agree to it, and bring the pool you actually plan to grant instead of the one the term sheet asked for.

The term sheet asks for a 15% post-money option pool, created pre-money.
Use Breakpoint Engine to show what that concession is worth.

Cap table: [paste or describe]. Round: [$X pre, $Y new money].

Run the round at pool sizes of 10%, 12%, and 15% post-money: calibrate
each variant to the preferred price, then report founder common value
and ownership for each. Then model the grants we actually expect to make
over the next 2 years [e.g. 6%] and show the value difference between
pool-as-asked and pool-as-needed. Give me the negotiation number: what
each pool point costs the founders in today's dollars.

Stacked SAFEs convert into real shares with real seniority the day the round prices. Build the post-conversion table once with your counsel’s mechanics, then let the engine price what everyone actually owns.

We have outstanding SAFEs: [$500k at $6M post-money cap, $750k at $8M
cap, $250k uncapped with a 20% discount]. Series A term sheet: [$10M pre,
$4M new].

Use Breakpoint Engine to model the conversion: build the post-round cap
table with every SAFE converted per its terms [apply your counsel's
conversion mechanics], then calibrate to the Series A price and report
what each SAFE holder, the founders, and the pool own — and what each
position is worth per share. Compare against the ownership we assumed
before conversion.

A round is never priced in isolation — it sets the seniority stack every later round sits on. Model the B and the C you expect, then read what your common is actually worth along each path.

Model our path from this Series A to exit with Breakpoint Engine.

Cap table after the round we're closing: [paste or describe]

Assume: Series B in ~2 years [$25M pre, $8M new, pool topped back to 12%],
Series C in ~4 years [$60M pre, $15M new], exit in year 6.

Stage by stage, build each pro-forma structure and value the allocation.
Report at every stage: founder ownership, common per-share value, and the
total preference stack ahead of common. Finish with exit outcomes at
[$100M / $250M / $500M]: founder proceeds under each path, and the exit
value where converting beats taking preferences for each series.

The breakpoint schedule is your exit story: where each series converts, where options come into the money, and which term in the stack moves your outcome most. Learn it while nothing is at stake.

Teach me my own exit waterfall with Breakpoint Engine.

Cap table: [paste or describe]

Walk me through the full breakpoint schedule tranche by tranche — who
participates, where each series converts, where each option strike
comes into the money, and why. Then value exits from $20M to $200M
in $20M steps and tabulate per-class proceeds. Tell me: at what exit
value does common start taking the majority of each marginal dollar, and
which single term in the stack moves that point the most?

A negotiation moves one term per phone call. Change exactly that term, hold everything else constant, and walk in knowing what the concession — or the win — is worth.

We're mid-negotiation on our Series A. Use Breakpoint Engine to price
individual term changes, one at a time.

Cap table: [paste]. Current proposed terms: [paste].

Starting from the proposed structure, recalculate with exactly one change
at a time, holding everything else constant:
1. Participation removed from the new preferred.
2. Pool at 12% instead of 15%.
3. Price per share up [5%].
4. The preference stacking senior vs pari passu with existing preferred.

For each change, report the founder common value difference in today's
dollars and at exits of [$50M / $150M]. Rank the four changes by what
they're worth to the founders, so I know which battles to pick.

More money at a lower price, less at a higher one, or a smaller round now and a bigger one later — each is a different bet on your own outcome distribution. Price all of them before choosing.

Help me choose between financing alternatives with Breakpoint Engine.

Cap table: [paste]. We need roughly [$4M–$6M].

Alternatives:
A. [$4M at $12M pre]
B. [$6M at $16M pre, larger pool refresh]
C. [$3M now at $12M pre, assume a $5M seed extension in 18 months]

Build each resulting structure and value it. Then compare founder common
across company outcomes — [struggle / base / great] exits at [$25M / $80M /
$250M] — and show where the alternatives cross. Summarize the real
trade-off in one table I can share with my cofounder.

Breakpoint Engine can pause a valuation mid-flight: change a term, see the diff, keep both branches until you choose. A negotiation session, not a batch job.

Open an interactive Breakpoint Engine scenario for our Series A
negotiation.

Cap table: [paste]. Proposed terms: [paste].

Begin a scenario session and pause at the breakpoint schedule — walk me
through it. Then, live: change the pool to 12% and show me the difference;
branch and try participating vs non-participating on the new money; step
through what each change does to common. Keep both branches until I
choose — then commit the one we pick and give me the final allocation.

Every long-horizon model on this page has the same shape: your AI lays out the years, rounds, and assumptions; Breakpoint Engine prices each capital structure the plan visits. The plan is narrative — every number anyone acts on is a deterministic, metered calculation.

Build a [6]-year financing model for our company with Breakpoint Engine.

You plan the timeline: financing rounds, pool top-ups, and exit windows
with assumptions I give you [or propose defaults and confirm]. For every
state the plan visits, price it with Breakpoint Engine — and keep a
running tally of the cost as you go. Deliver: the year-by-year table,
per-class values at each state, and every assumption listed next to the
numbers it produced.