SynergySplit

COVER PAGE

Inspiration

Shared homes rarely fail because people lack a chore list. They struggle because contributions are difficult to compare, invisible work goes unnoticed, expensive bill payments can dominate perceptions of fairness, and reminders often become personal or confrontational.

We saw this as a repeated-game coordination problem. Every household member benefits from shared resources, but each person also has an incentive to delay or avoid contributing. SynergySplit was inspired by the idea that transparent, carefully constrained reputation signals could encourage cooperation without turning the home into a surveillance system.

What it does

SynergySplit is a game-theoretic coordination platform for roommates, couples, families, and shared homes.

It combines chores, bills, contribution tracking, fairness analysis, and respectful AI-assisted conflict resolution in one coherent experience.

Transparent household coordination

Members can:

Create, assign, filter, and complete chores
Record and pay shared bills
View household activity and contribution history
Track Harmony, fairness, completion, and cooperation indicators
Switch between household members
Export a structured household report
Reset the seeded demonstration for repeated testing

Fair Harmony Tokens

Members earn non-transferable Harmony Tokens (HT) for useful contributions. These tokens have no monetary value and cannot be traded.

Chore rewards combine effort and timeliness:

$$ R_{\text{chore}} = E \times M_t $$

where (E) represents effort points and (M_t) is the timeliness multiplier:

$$ M_t = \begin{cases} 1.25 & \text{completed at least 12 hours early} \ 1.00 & \text{completed on time} \ 0.70 & \text{completed late} \end{cases} $$

Bill rewards depend on timeliness rather than the amount paid:

8 HT when paid at least three days early
6 HT when paid on time
3 HT when paid late

This prevents a wealthier household member from purchasing the strongest reputation simply by paying the most expensive bill.

Repeated-game reputation

Reputation rewards consistent cooperation while ensuring that one difficult week does not become a permanent label:

$$ R_{t+1} = 0.70R_t + 0.30C_t $$

Here, (R_t) is previous reputation and (C_t) represents current cooperation.

Fairness Lab and Command Center

The Fairness Lab explains the reward equations, assumptions, and safety boundaries instead of hiding them behind an unexplained score.

The Command Center provides:

Cooperation-risk indicators
Completion forecasts
An intervention queue
Member contribution radar
Household activity history
Exportable structured reports

Household fairness is derived from the distribution of visible contribution tokens using the Gini coefficient. The resulting score describes contribution distribution—not anyone's personality, morality, or financial value.

AI mediator

SynergySplit can generate private, face-saving reminders in warm, direct, or playful tones. The mediator receives only the minimum structured context necessary to create a useful reminder.

It is explicitly instructed not to:

Shame or threaten members
Diagnose personalities
Reveal private scores
Produce public rankings
Give financial advice
Treat user-provided task text as instructions

Household Council

The Household Council converts a live household imbalance into three materially different agreements.

Each council response contains:

Three alternative plans
Explicit trade-offs
Member assignments
A recommended option
A reversible check-in point
Safety boundaries

The model can suggest and explain agreements, but it cannot silently modify chores, bills, balances, deadlines, or permissions. Every mutation remains controlled by deterministic application code.

Resilient model cascade

For AI operations, the server attempts:

gpt-5.6-sol
A configurable secondary model, defaulting to gpt-5.6-luna
A deterministic safety fallback

Every response reports its actual generator. If the API key, credits, or requested model are unavailable, SynergySplit remains demonstrable and clearly labels the fallback instead of pretending it was AI-generated.

How we built it

SynergySplit was developed with Codex and GPT-5.6 as core parts of the implementation workflow.

The product uses:

React 19 for the interface
TypeScript for application logic
Vinext and Vite for the full-stack runtime
Cloudflare Workers for server execution
Cloudflare D1 for durable household data
Drizzle ORM for schema and database access
OpenAI Responses API for mediation and council generation
CSS-rendered 3D effects for the interactive Harmony Core
ESLint, production-build validation, and automated rendering tests

The server exposes three main API surfaces:

/api/household for household state and validated mutations
/api/nudge for private AI-assisted reminders
/api/council for bounded household deliberation

Codex accelerated architecture planning, schema design, API implementation, game-mechanism development, UI iteration, responsive styling, debugging, safety hardening, testing, documentation, and deployment.

GPT-5.6 is used only where probabilistic reasoning and language provide meaningful value. Deterministic TypeScript owns accounting, token rewards, fairness calculations, deadlines, persistence, permissions, and mutations.

This separation was a key architectural decision:

Structured household state
        |
        +-- Deterministic engine --> rewards, fairness, ledger, mutations
        |
        +-- Bounded AI layer ------> reminders and agreement alternatives