I’m Matthew. Year 12, Melbourne.

3 months ago I had one idea: what if you could see how a decision actually lands before you commit?

Not analysis. The actual reaction.

You submit a decision. 100 agents spawn investors, customers, competitors, press. They interact for 12 rounds without you in the room. Coalitions form. Narratives spread. By round 12 you have a map of who resists, who aligns, and what counter-narrative takes hold.

Before the real email goes out.

Last week a founder here asked whether to build Android or fix retention first. We ran it. Adversarial audit caught the framing was biased toward Android from the start.

Reframed neutral. Option C emerged PWA while fixing retention simultaneously. Competitor agents counter-positioned by round 3. Retention became the make-or-break variable by round 8.

Took 20 minutes not 20 hours

Most tools tell you what to decide. Arbiter shows you what happens when you do.

If you’ve crossed zero-to-one what actually moved the needle?

Solo founder. 154 users. One question: Android now or retention first?

We ran it through Arbiter. Here’s what the simulation actually showed.

Ruling: Option C — PWA for Android, fix retention simultaneously. 81% certainty.

The adversarial audit caught the framing first. “Is it time for Android?” presupposes Android is the right move. System rewrote the question neutral.

That’s what opened Option C — a PWA removes the binary entirely. Android surface area without a parallel engineering workstream.

Then the stakeholder simulation ran.

12 rounds. Here’s what emerged:

Round 1-4: Existing iOS users neutral on PWA, shifted supportive once they understood it didn’t touch iOS quality.

Round 3: Competitor agents started counter-positioning around “half-baked Android experience.” The obvious bear case.

Round 6: Android demand coalition formed around accessibility narrative. Louder than the retention concern.

Round 8: Retention becomes the make-or-break variable. Not platform. Retention.

Round 12 verdict: “PWA threads the needle. Competitor narrative loses steam if quality holds. The retention problem doesn’t disappear — it’s what determines whether any of this works.”

The finding nobody asked for:

The niche (male pelvic health) limits word of mouth structurally. Platform expansion doesn’t fix distribution. That signal stayed flat across all 12 rounds.

Flip signal: if a competitor ships native Android in the same niche within 60 days, the ruling changes. That’s the only variable worth watching.

The whole thing took 15 minutes not days of waiting for feedback on reddit.

I’m Matthew. 17, Year 12, Melbourne. Registered sole trader. Zero paying customers.

That last part matters. This isn’t a success story.

The idea

ChatGPT gives you a list. I wanted something that makes the call.

A tool that takes a high-stakes business decision, runs it through a structured framework, and delivers a defensible ruling. Constraint-driven. Evidence-backed. Auditable.

Started with no-code tools and an API key. Embarrassing prototype. Kept going.

The part that changed everything

After the framework produces a ruling, something else runs.

It builds a map of every stakeholder connected to your decision. Investors. Customers. Competitors. Press. Regulators. Each one gets a distinct identity — incentives, biases, influence level, memory.

Then they interact.

Not with each other through you. With each other directly. On simulated social platforms. Posting. Replying. Forming coalitions. Shifting opinions. Amplifying narratives. Some agents follow influencers. Some are contrarian by default. Some start neutral and get pulled.

By round 12 you have a stakeholder network showing exactly who resists your decision, who aligns, which coalitions formed, and what the counter-narrative looks like.

Before the real email goes out.

A real example

Pricing decision. Raise 20% before Q3 or hold steady.

The framework said: do it, sequence carefully.

The simulation said: three enterprise customer agents cooled within 4 rounds. A competitor agent began counter-positioning by round 6. A price-sensitive segment formed a coalition around “fairness” by round 9. An industry analyst agent amplified the competitor narrative.

None of that was in the spreadsheet.

The founder adjusted their go-to-market before sending anything. Sequenced the announcement differently. Got ahead of the competitor narrative.

That’s the product.

What building at 17 actually looks like

Finishing a VCE exam at 3pm. Shipping a feature at midnight. Debugging agent convergence issues at 1am because all 100 agents kept agreeing with each other — turns out when you give LLMs the same context and a centralised feed, they just agree. Fixed it with information asymmetry and isolated memory.

Two weeks ago a Reddit commenter told me it was “an LLM wrapper in its purest form” two hours after I shipped the simulation engine.

That one stings. Then it clarifies something: positioning matters as much as product.

The thing nobody tells you

Distribution is harder than engineering.

11 signups. Zero paying customers. The product works. The pipeline runs. The briefs are real.

Sent 26 LinkedIn DMs to fractional CFOs today. Two rejections. Twenty-four pending.

We’ll see.

What I’ve actually learned

A working product with no customers is just expensive code.

Talk to customers before you build. Everything else is speculation dressed as strategy.

Ship mediocre and get feedback. Waiting for perfect ships nothing.

The market will misread your product if you haven’t nailed the narrative. Same product, different framing, completely different reaction.

Where I’m at

V2 live at arbiterbriefs.com. Private beta, request access. Simulation engine shipped last week. PDF generation being rebuilt this week — current version looks like a screenshot, not a board document.

Goal for next 30 days: one paying customer. That’s the only metric that matters.

If you’ve been here — pre-revenue, zero to one, trying to close the first — what actually worked?

And if you’re a young founder wondering if it’s possible to build something real while still in school: it is. Just harder and lonelier than anyone says.

The illusion of the lifestyle lived by the wealthy genuinely hooked me. The money, yachts, jets and the rest that comes with it.

The thought of becoming financially free by 20 and not having the worry about finances for the rest of my life was something I always wanted.

I never believed in the ‘F students are the inventors’ gimmick rather I actually don’t mind school and get decent grades. The F students at my school wouldn’t have the intellectual capacity to put a prompt into chatgpt.

So I spent weeks watching subreddits, reading about other people’s ideas until I finally found a niche that didn’t have a large market presence yet.

My first build of arbiter, looking back at it now was so bland, a glorified gpt wrapper at best. even using gpt4.0 😭

It took me 2 months to build something real arbiterbriefs.com

In a nutshell:
Integrated multi-swarm agency that deliberates your business decisions. Each agent takes on the role of a stakeholder (Customer, shareholder, competitors).

These deliberations help to support an overall arbitration pipeline that help support business decision making.

Is this something you would use as a founder? And if so how often?

Most AI tools stop right before the hard part:
making the actual decision.

They summarise information.
List pros and cons.
Generate “considerations.”

Then push the responsibility back onto you.

That works for brainstorming.

It breaks when the stakes are real:
- pricing strategy
- market expansion
- hiring
- acquisitions
- restructuring
- capital allocation
- operational tradeoffs

We built Arbiter because we think AI should do more than assist thinking.

It should pressure-test it.

Arbiter is a multi-agent decision intelligence system designed to simulate executive-level strategic reasoning and deliver a formal ruling on complex business decisions.

Not:
> “Here are some ideas.”

But:
> “Based on the evidence, scenario modelling, risk analysis, and competing internal arguments, this is the decision we recommend.”

Every brief includes:
- a final ruling
- confidence scoring
- dissenting opinions
- downside analysis
- second-order effects
- implementation risks
- scenario simulations
- a phased 30-day execution roadmap

The interesting part isn’t just the output.

It’s the internal deliberation process.

Different AI agents debate the decision from competing perspectives:
- finance
- operations
- growth
- legal exposure
- market positioning
- behavioural incentives
- execution feasibility
- long-term strategic consequences

Arbiter then synthesises the conflict into a single board-style recommendation.

One recent use case:

A founder was considering aggressive price increases across their business.

Internally, leadership was divided:
- finance wanted margin expansion
- sales feared churn
- operations wanted simplicity
- growth teams wanted experimentation

Most AI tools simply reflected the disagreement back at them.

Arbiter instead:
- modelled customer sensitivity
- simulated churn scenarios
- evaluated revenue concentration risk
- stress-tested rollout strategies
- generated counterarguments
- identified operational bottlenecks
- analysed second-order impacts on retention and perception
- then delivered a final recommendation with a phased implementation strategy

The conclusion wasn’t:
> “raise prices.”

It was:
> selective increases by segment, staggered rollout timing, retention protection mechanisms, and revised positioning language to minimise churn risk.

That’s the difference.

Most businesses don’t actually suffer from a lack of information.

They suffer from:
- fragmented reasoning
- analysis paralysis
- conflicting incentives
- unclear tradeoffs
- no accountable decision framework

We think the next generation of AI products won’t just generate answers.

They’ll function more like:
- executive councils
- strategy teams
- arbitration panels
- decision engines

Systems that can reason through uncertainty instead of just describing it.

Curious what people think:

Would you trust an AI system to make a high-stakes business recommendation if the reasoning, simulations, and dissenting arguments were fully transparent?

arbiterbriefs.com

Hi all,

I’m building a tool at 17 (for context) that simulates stakeholder reactions and arbitrates decisions your business makes.

I’ve tried

- Reddit Posts/Comments
- Cold Email
- Cold Linkedin
- Dev To posts

my struggle with linkedin is that i don’t look very reputable. I’m a high schooler so naturally I only have 3 connections with my work experience as KFC and then Full stack developer.

my target audience is fractional CFOs founders and operators. right now i’m struggling to get people on my waitlist, as i have a total of 1 person on it.

any feedback would be appreciated.

Most post-mortems say the same thing: the decision wasn’t wrong, the execution was. The market reacted differently than expected. Stakeholders pushed back in ways nobody modeled.

We built Arbiter to fix that.

How it works:

Submit a decision (pricing change, bridge vs. layoff, market entry). Arbiter runs constraint-driven analysis → produces a ruling.

Then MiroFish spawns 100+ AI agents representing your actual stakeholder landscape — investors, customers, competitors, press — and simulates 30 days of reactions.

You see who resists. Who aligns. Which coalitions form. What the counter-narrative looks like before it happens.

For VCs specifically:

•	Run it on portfolio company decisions before board meetings  
•	See how a pricing change lands with enterprise customers before the email goes out  
•	Model investor reaction to a bridge vs. restructure decision  
•	Get a board-ready brief in 90 minutes, not 11 hours

What it outputs:

Constraint scorecard. Evidence base with citations. Stakeholder network graph. Swarm verdict. 30-day implementation plan. Investor-ready PDF.

Currently in private beta with fractional CFOs and operators. Opening slots for VC firms who want to run it on live portfolio decisions.

arbiterbriefs.com

We were supposed to launch this yesterday. It’s now 2am and I’m debugging agent convergence issues. Here’s the honest version of what happened.
The plan: MiroFish simulates stakeholder reactions to business decisions. Takes a decision, spawns 100+ agents, watches them interact, outputs a network graph + verdict.

What we thought would work:
• Seed agents with real data (customer churn, market signals)
• Let them interact for 12 rounds
• Get emergent behaviour

What actually happened:
All agents converged on the same opinion by round 3. Every. Single. One.
The price increase decision? All agents agreed it was reasonable. The acquisition? All agents said do it. The market layoff? All agents said it’s necessary.
Turns out when you feed LLMs the same context + let them see each other’s opinions in a centralized feed, they just… agree with each other.

The fix (that took 4 hours):
1. Fragmented the information feed — agents now see curated Twitter/Reddit-like feeds, not all other opinions at once
2. Added heterogeneous agent types — not all rational actors. Some follow influencers, some are emotional, some are contrarian by default
3. Isolated memory — each agent has independent long-term memory, not shared state
Round 12 now: actual disagreement. Coalitions forming. Realistic market dynamics.

What I learned:
• Multi-agent simulation is not “run LLM N times and hope”
• Information architecture matters more than model choice
• Emergent behavior requires friction — asymmetric info, diverse incentives, memory isolation

The real problem:
I almost shipped this with agents that all agreed. Would’ve looked impressive (clean narrative!) but been completely useless (no actual insights).
Caught it at 1:53am because we had a founder test it. She said: “Wait, why does everyone have the same opinion?”

That question saved the launch.
What’s next:
• Publish a detailed post on agent calibration (promised it earlier, time to deliver)
• Open-source the information fragmentation layer
• Sleep

If you’re building multi-agent systems: test with real humans early. Don’t let the model’s output bias trap you into thinking convergence = correctness.

We just integrated MiroFish — a multi-agent simulation engine — into Arbiter Briefs. Now when you make a decision, you don’t just get a recommendation. You get a simulation of how investors, competitors, and customers will actually respond.

The Problem

You’re deciding whether to acquire a competitor. Your brief says it’s a good move. But will your board agree? Will customers switch? Will it trigger antitrust scrutiny? You won’t know until you’ve already signed the term sheet.

How It Works

Step 1: You make a decision

•	Define constraints (budget, timeline, risk tolerance)  
•	Upload financial context (P&Ls, cap tables)  
•	Arbiter runs constraint-driven analysis → produces a ruling

Step 2: MiroFish simulates the future

•	Takes your decision + context  
•	Extracts stakeholders and their incentives from the research  
•	Spawns 100+ AI agents with distinct personalities, biases, and influence levels  
•	Simulates their reactions across 12 rounds (30 days of social dynamics)  
•	Tracks which coalitions form, which arguments win, where resistance emerges

Step 3: You see the stakeholder landscape

Each agent represents a real stakeholder type:
• Blueridge Partners (software pricing analyst) — 18 actions, influential
• Deloitte (enterprise advisor) — 9 actions, skeptical
• Consumer Reports (independent review) — 8 actions, potential critic
• WCA Tech (B2B thought leader) — 6 actions, opinion-shaper
• Plus individual operators like “I” (young professional considering if price increase impacts them)

The Network View

This isn’t just a list. It’s a living relationship map:
• 34 entities. 25 relationships.
• Gold nodes = stakeholders. Blue = your company. Pink = wild cards.
• Lines show influence flows. You can see coalitions forming in real-time.

The Swarm Verdict synthesizes what emerges:
“Price increases and dynamic pricing strategies will become key tools for software companies to cope with market changes. In a simulated future environment, the acceptance of price increases and market reactions exhibit complex and diverse dynamics. Customers mention price sensitivity… Deloitte emphasizes economic climate impact… Competitors might exploit this as a market opportunity…

This isn’t a prediction. It’s a reasoning chain showing what the market would likely do if you moved forward.
Why This Matters for Decision-Making

Before MiroFish:
• You make a decision
• You hope stakeholders accept it
• 6 months later, you’re surprised by backlash

With MiroFish:
• You simulate the decision first
• You see which stakeholders will resist (and why)
• You adjust your go-to-market, timing, or framing before committing
• You have an evidence-based narrative for your board

Technical Side

MiroFish works by:

1.	Graph extraction — parses your decision + research → builds a knowledge graph of entities and relationships

2.	Agent generation — creates personas for each stakeholder (personality, bias, influence, memory)

3.	Parallel simulation — agents interact on Twitter + Reddit-like platforms simultaneously

4.	Social dynamics — opinions shift, coalitions form, arguments propagate

5.	Report synthesis — AI analyzes 12 rounds of interactions → produces structured verdict with confidence signals

The Real Insight

Most decision frameworks stop at “here’s the recommendation.” Arbiter + MiroFish goes further: “Here’s the recommendation, and here’s how the world will respond.”
For founders and operators making high-stakes decisions without analyst teams, that’s the difference between confidence and certainty.

Try It Free

We’re shipping this to our waitlist now. If you want to test drive it on a real decision, we have spots open.
arbiterbriefs.com

I’ve been studying how successful founders make high-stakes decisions (raise vs. bootstrap, pivot vs. double-down, pricing changes, key hires). After analyzing 50+ cases, I found most founders skip the same 6 critical questions. Here’s the framework

1. “What’s actually non-negotiable here?”

Most founders list 10+ “constraints” but only 2-3 are real. The rest are preferences disguised as requirements.
Example: “We need to maintain 95% customer retention” might be real. “We need to keep our current pricing model” might just be fear of change.
Action: Write down every constraint. For each one, ask: “What happens if we violate this?” If the answer is “the business dies,” it’s real. If it’s “we’d be uncomfortable,” it’s not.

2. “What assumptions am I making that could be wrong?”

Failed decisions usually hinge on 1-2 false assumptions that seemed obviously true at the time.
Example: “Our customers will pay 20% more for premium features.” Really? Have you tested this? Or are you assuming based on what you would pay?
Action: List your 3 biggest assumptions. For each one, ask: “How could I test this in 2 weeks with $500?” If you can’t test it cheaply, acknowledge it’s a gamble.

3. “Who gets hurt if I’m wrong?”

Founders think about upside but underestimate who bears the downside risk.
Example: Raising a big round sounds great until you realize your team now has 18 months to hit an impossible growth target or everyone gets laid off.
Action: Map every stakeholder (team, customers, investors, family). For each option, ask: “If this fails, what happens to them?” Make the pain visible.

4. “What does this decision make easier vs. harder?”

Every choice opens some doors and closes others. Great founders think 2-3 moves ahead.
Example: Taking VC money makes hiring easier but customer discovery harder (you’re now optimizing for investor metrics, not customer problems).
Action: For each option, list what becomes easier and what becomes harder. Often the “harder” list tells you more than the “easier” list.

5. “How will I know if I was right?”

Most founders make decisions but never define what success looks like. Result: they can’t learn from their choices.
Example: “We’ll pivot to enterprise” is not a decision. “We’ll land 3 enterprise customers at $50k+ ARR each within 6 months” is a decision.
Action: Set 3 specific metrics + timeframes for each option. If you can’t define success, you’re not ready to decide.

6. “What would I tell my best friend to do?”

This cuts through ego, sunk costs, and emotional attachment. Often your gut knows the right answer but your brain is making excuses.
Action: Literally roleplay this. Pretend your best friend came to you with this exact situation and data. What would you tell them? That’s probably what you should do.

Why This Works
Most founders get paralyzed because they’re trying to predict the future. This framework doesn’t predict anything. It just makes your assumptions explicit, your constraints clear, and your risks visible.
You’ll still make mistakes. But you’ll make them faster, with more information, and you’ll learn from them instead of repeating them.

The goal isn’t perfect decisions. It’s informed decisions that you can execute on confidently.

PS: I’m 17 and building a tool that automates this kind of decision analysis for founders. Still learning and building

Most founders spend 2-3 weeks analyzing spreadsheets for one major decision (raise vs. bootstrap, pivot vs. double-down, pricing changes). They get contradictory advice. They stay stuck.
Arbiter fixes this. Feed it your decision + financial PDFs. Get back a board-ready brief with a clear recommendation.

Technical pipeline:
1. PDF extraction — GPT-4o pulls metrics from P&Ls, balance sheets, cap tables (no manual data entry)
2. Financial modeling — sensitivity analysis on key inputs (runway, growth, burn rate)
3. Research integration — web search + document context combined
4. Stakeholder simulation — multi-agent modeling of customer/competitor reactions
5. Ruling synthesis — everything compiled into executive summary + 30-day action plan

Sample output: Upload a P&L showing $2.4M revenue. Ask “should we raise Series A or bootstrap?” System extracts runway (18 months), models 3 scenarios, researches market conditions, simulates stakeholder responses, outputs: “Bootstrap. Here’s why + implementation roadmap.”

Why this matters: Decision paralysis kills startups. Analysis should take hours, not weeks.

Current state: V2 launching Q3 2026.

Early access: arbiterbriefs.com

Tech stack: React + Node.js + PostgreSQL + GPT-4o + Railway. Building in public.

Free sample: DM me a business decision you’re facing, I’ll run it through the engine and send you the brief.

17, from Melbourne AU, shipping features between study etc. Open to all feedback

Most founders spend 2-3 weeks analyzing spreadsheets for one major decision (raise vs. bootstrap, pivot vs. double-down, pricing changes). They get contradictory advice. They stay stuck.
Arbiter fixes this. Feed it your decision + financial PDFs. Get back a board-ready brief with a clear recommendation.

Technical pipeline:
1. PDF extraction — GPT-4o pulls metrics from P&Ls, balance sheets, cap tables (no manual data entry)
2. Financial modeling — sensitivity analysis on key inputs (runway, growth, burn rate)
3. Research integration — web search + document context combined
4. Stakeholder simulation — multi-agent modeling of customer/competitor reactions
5. Ruling synthesis — everything compiled into executive summary + 30-day action plan

Sample output: Upload a P&L showing $2.4M revenue. Ask “should we raise Series A or bootstrap?” System extracts runway (18 months), models 3 scenarios, researches market conditions, simulates stakeholder responses, outputs: “Bootstrap. Here’s why + implementation roadmap.”

Why this matters: Decision paralysis kills startups. Analysis should take hours, not weeks.

Current state: V2 launching Q3 2026.

Early access: arbiterbriefs.com

Tech stack: React + Node.js + PostgreSQL + GPT-4o + Railway. Building in public.

Free sample: DM me a business decision you’re facing, I’ll run it through the engine and send you the brief.