These are working sessions you can start for free — term-sheet comparison,
liquidation preferences, option-pool costing, SAFE conversion, future rounds, and exit waterfalls — each with a
prompt you can paste into any connected AI and adapt. You bring the questions and the numbers; your AI reasons;
Breakpoint Engine calculates.
Use these prompts with Claude, ChatGPT, Codex, Cursor, or Claude Code once the connector is set up — see the
guides for Claude, ChatGPT, and Cursor. Replace the bracketed
pieces with your numbers, or paste the documented
JSON format for exact control. A genuine run shows opm_* tool calls and consumes work units — that's how you know the numbers came from the engine, not from
language-model arithmetic.
Formation to option pricing
Prepare through the raise. Build on the record when it closes.
Start the war room with founder agreements and equity records. Explore proposed terms as they arrive, then
reconcile the final agreements at closing. When your team needs option grants, the open valuation skill
guides preparation of a cited, independently checked, draft 409A
analysis package—with the engine performing the backsolve and allocation where appropriate rather than asking the AI to improvise
the mathematics.
A recent-round backsolve is not automatically appropriate in every case. The workflow tests the method, material
events, assumptions, and evidence before calculating. See the founder war room and 409A workflow →
Founder jobs
Walk the raise like you own the model
A raise deserves more than one answer. Every term-sheet variant, pool size, and exit assumption is a cheap
question once the engine is doing the waterfall — so ask all of them before you sign, not after.
Does our cap table match our company records?
Reconcile founder shares, preferred stock, options, SAFEs and warrants against executed records. Ownership percentages describe shares; security rights determine economics.
Review our capitalization against the executed documents in this War Room. Cite each source, separate outstanding from proposed securities, and identify missing approvals or conflicting terms. Ask me to confirm unresolved inputs before using Breakpoint Engine to calculate the economic preference stack.
Are our financing records ready for diligence?
Use your AI to inventory signed agreements, board approvals, grants and amendments. Preserve missing evidence as an open question.
Inventory this Founder War Room for financing diligence. Do not move or overwrite source files. Reconcile the document index with the capitalization and flag missing executed agreements, approvals and amendments. Save a dated readiness review with source citations and next actions. Use Breakpoint only where financial calculation is required.
What evidence is missing for our common-stock valuation?
Prepare dated evidence and supported assumptions for common-stock valuation analysis. The computation supports the analysis; it is not an independent 409A safe-harbor opinion.
Review our War Room for common-stock valuation as of [DATE]. Identify the relevant financing, security rights, financials, material events and market evidence. Explain which assumptions need support and whether a recent-round backsolve is appropriate before performing any calculation. Keep unresolved facts and review requirements visible.
Which term sheet is better for us?
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.
What does this liquidation preference mean for us?
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.
What does increasing the option pool cost us?
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.
How will our SAFEs dilute founder ownership?
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.
What happens if the next round is higher or lower?
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.
What do founders receive at different exit values?
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?
Negotiate one term at a time
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.
Compare financing alternatives across outcomes
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.
Patterns
Chain calculations into models
The engine prices one capital structure at a time; your AI chains those calculations into anything with a
timeline. Two patterns underlie every card above.
Design the round live — interactive scenarios
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.
The multi-year pattern: your AI plans, the engine prices
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.
Boundaries
Breakpoint Engine is the computation layer: deterministic valuations, breakpoint schedules, and interactive
scenarios. The outputs above are analysis, not opinions — your assumptions, your counsel's advice, and your
decisions remain yours. Cap tables are passed as tool inputs, computed on, and never stored as a system of
record; the delivered result is held for up to 48 hours so a retried request is answered rather than re-run and
re-billed. See Methodology.