Synachron — Product & System Guide

In one sentence: Synachron lets a decision-maker describe a scenario — a new product, an ad campaign, a policy, a political message — and, within seconds, see how a population of realistic, psychologically rich simulated people would react to it.

This document explains what Synachron does, why it is valuable, exactly how it works under the hood, and what a single run looks like (with a worked sample). It is written for both non-technical readers (investors, partners, clients) and engineers.


1. The Problem We Solve

Before launching anything, organizations ask the same question: "How will people respond?"

Traditionally there are two ways to answer:

  1. Real market research — surveys, focus groups, pilot launches. Accurate, but expensive and slow: weeks to months, tens of thousands of euros per study, and the sample is limited to whoever you can reach.
  2. Gut feel — senior people guess. Cheap, but wrong often enough to be dangerous.

Neither scales. You cannot run a real focus group 200 times to test 200 variations of an ad. Most decisions are still made blind.

What Synachron does instead

Synachron builds a standing library of synthetic people — "agents" — each with a full psychological profile (demographics, values, personality, political leaning, religious views, life experiences, media diet). When you want to test something, you pick how many people (up to 1,000) and the system samples that many agents from the library, feeds them to an AI along with your scenario, and returns a structured report: approval rate, overall sentiment, which sub-groups love it or hate it, why, and what they will actually do.

A study that would take a month costs one AI call and runs in under a minute.


2. How It Works — The Plain-Language Version

Analogy: Imagine you could clone 1,000 real people into a room, hand them your campaign flyer, and ask them all to argue about it. You cannot. But you can ask a brilliant analyst: "Here are 1,000 one-page biographies of real, diverse people — tell me how this room would react." That is Synachron.

  1. You create a population once. Generate synthetic agents (in batches of your choosing). Each becomes a permanent record in the library. You can target a country, a political leaning, an age band, etc.
  2. You write a scenario. Describe the product, message, policy, or campaign you are testing. Attach images, PDFs, or documents if relevant.
  3. You pick the audience size. A slider lets you choose 10 to 1,000 agents. The system samples them from the library — randomly, or filtered by demographics.
  4. The engine runs. In one AI call, it summarizes the sampled agents and your scenario, then asks the AI to predict the population's reaction.
  5. You get a report. Approval %, sentiment, the key sub-groups (who supports, who opposes, and why), actionable insights, and predicted behavior.
  6. You explore and export. Charts, demographic breakdowns, per-agent responses, PDF/CSV exports, and side-by-side comparison of two runs.

3. A Worked Sample

To make this concrete, here is an end-to-end example of a single simulation.

Step 1 — Create the population (one-time setup)

An admin opens Agent Profiles → Generate and generates 500 Greek agents. The system produces people like:

Eleftheria, 34, female, Athens. Bachelor's degree, marketing manager, middle income, married, no children. Politically center-left; atheist. High openness, high anxiety, low trust in institutions, moderate economic resentment. Triggers: housing crisis, women's rights. Trauma: lost her job in the 2020 pandemic. Reads Kathimerini, Instagram, Reddit.

Giorgos, 61, male, Kozani. High-school diploma, retired factory worker, lower-middle income, widower, two children. Far-right; devout Orthodox Christian. High authoritarianism, high tribalism, strong nationalism. Triggered by "national identity." Reads TV news, Facebook.

These two — and 498 others — are stored permanently and reusable across any number of simulations.

Step 2 — Write the scenario

In Simulations → New Simulation:

  • Title: "Subsidized EV leasing program — 2026 relaunch"
  • Type: Policy Proposal
  • Description: A government-backed scheme offering €150/month leasing for electric vehicles, targeting urban and suburban drivers, available to households earning under €40k. Includes a €2,000 scrappage bonus for trading in cars over 15 years old.

Step 3 — Pick the size

Using the slider, the admin selects 200 agents.

Step 4 — Run

Click Run, choose random sample (or filter by e.g. age 25–60, income low/middle). The backend:

  • Loads 200 random active agents.
  • Builds a compact text biography of each.
  • Sends one prompt to the AI: "Here is a population. Here is a policy. Predict how they react."
  • Saves the structured answer.

Step 5 — The report

The run card shows, live:

  • Overall sentiment: positive
  • Approval rate: 58%
  • Executive summary: "The proposal lands well with urban middle-class drivers under 45 who view EV as a status-tech shift, but meets skepticism among older rural and lower-income voters who doubt their charging access and fear hidden costs. The scrappage bonus is the most popular element…"
  • Key segments:
    • Young urban professionals (31%): 72% positive — see it as affordable, modern, green.
    • Rural older drivers (24%): negative — "no chargers near me," "EV is for Athens people."
    • Lower-income families (19%): mixed — want it but fear €150/month is still too much.
  • Most supportive: Salaried 28–44, Athens/Thessaloniki, center voters.
  • Most opposed: 60+, rural, right-leaning, low institutional trust.
  • Predicted behavior: "Adoption concentrated in cities; Rural/non-urban targets expect uptake only if paired with public-charging rollout messaging."
  • Insights: "Lead the campaign with the scrappage bonus in messaging; pair it with a visible charging-infrastructure commitment; secondarily target messaging "affordability" themes to 30-44 suburbanites to pull the ambivalent middle house."

Step 6 — Explore

  • Charts: approval by age, by occupation, sentiment breakdown.
  • Per-agent responses: click the Users icon to read how individual agents were characterized.
  • Export to PDF/CSV: for the board meeting.
  • Compare: run the same scenario with a tweaked message and compare side-by-side.

Total cost of this study to the user: one AI call — fractions of a euro of compute.


4. What an Investor Should Know

The moat

  1. Population realism. Our agents are not flat personas. They carry full psychological inventories (Big Five personality, Moral Foundations Theory, aggression, authoritarianism, tribalism, anxiety, institutional trust, etc.), religion, life trauma, and media diet. This is why predictions feel real: the model has enough per-person texture to reason about sub-groups the way a real pollster would.
  2. Cost economics. A traditional focus group study routinely costs €15–40k and takes weeks. Synachron runs a comparable (directionally accurate, not statistically representative) study in under a minute for the cost of one AI call. That means clients can run 200 variations for the price today's tools charge for one — a qualitative shift in how often testing happens.
  3. Reusable population. The same agent library serves every future simulation. It compounds: once the library exists, the marginal cost of a new study is ~zero marginal data cost plus one AI call.

Who uses it

  • Political & government: test messages, policy proposals, crisis responses (the Sync Civic and Sync Elections modules).
  • Brands & agencies: creative testing, product launches, pricing, segmentation (the Sync Market module).
  • Researchers & consultancies: quick directional reads, scenario planning, evidence-backed narratives.

What it is not

Synachron does not replace statistically representative polling. It produces directional, psychologically-grounded foresight — a fast, cheap "smoke test" before you spend real research money, and a way to test ideas you could not field-test at all. It is a decision-support tool, not a crystal ball.

The unit economics (at the platform level)

  • CreateSimulatedAgents uses a premium model (Claude Sonnet) and more credits per call.
  • runSimulation uses the default model — one call per simulation.
  • analyzeGreekTrends (Greece-specific political forecasting) uses the premium model. Credit consumption scales with number of simulations and population-create operations, both of which are user-driven.

5. How It Works — The Technical Version

For engineers and due-diligence readers, here is the actual pipeline.

5.1 Architecture

React + Vite + Tailwind + shadcn/ui  (frontend)
   marketing site  +  admin console (/admin)
        |  base44 SDK over HTTP
        v
Base44 BaaS
   - Auth (built-in; admin / user roles; RLS per record)
   - Entities (Agent profiles, Simulation runs, audit, etc.)
   - Integrations (Core.InvokeLLM, UploadFile, SendEmail, ...)
   - Backend functions (Deno handlers)
       createSimulatedAgents  •  runSimulation  •  analyzeGreekTrends

5.2 The "one LLM call per simulation" decision

We do not simulate each of the 1,000 people one-by-one (that would be 1,000 LLM calls — slow and expensive). Instead we summarize each sampled agent into a single line of text and pass the whole population summary to one AI call that returns an aggregated analytical report. This is the key design choice that makes the product economics work.

5.3 Backend functions

All functions are Deno HTTP handlers in base44/functions/<name>/entry.ts. They authenticate via base44.auth.me(), operate on entities through the SDK, and call base44.integrations.Core.InvokeLLM. The frontend triggers them with base44.functions.invoke('<name>', payload).

createSimulatedAgents — generates AgentProfile records.

  • Input: { count, constraints } (constraints may set country, political_views, income_bracket, age_group, recent_news_context). count capped at 10,000.
  • Builds a realism-focused prompt enforcing internally-consistent profiles. Without a fixed country, agents are distributed across 20 supported countries (weighted toward Greece & Cyprus).
  • Calls InvokeLLM (model: claude_sonnet_4_6) with a JSON schema enforcing every field.
  • Normalizes results: validates country against the allow-list, assigns a valid city if missing, coerces booleans, sets status.
  • Bulk-creates via AgentProfile.bulkCreate.
  • Returns { success, count, agents }.

runSimulation — the engine.

  • Input: { simulation_id, filter_mode, agent_filters }. filter_mode is 'random' or 'filtered'.
  • Loads the run, marks status 'running'.
  • Resolves the pool: random fetches up to min(agent_count * 3, 3000) active agents; filtered loads up to 2000 and filters in-memory by political_views, income_bracket, gender, education_level, country, age_group.
  • Shuffles and slices to agent_count (UI allows up to 1000).
  • Builds a one-line text summary per agent. Attaches any simulation attachments (file URLs) as LLM context.
  • Calls InvokeLLM (default model) requesting: overall_sentiment, approval_rate (0–100), results_summary, key_segments[], insights[], top_supporters_profile, top_opponents_profile, predicted_behavior. A response_json_schema enforces the shape.
  • Persists everything and sets status 'completed'.
  • On error: status 'failed' (set via service-role client), returns HTTP 500.
  • Frontend fires the function fire-and-forget, then polls the simulation record every 3s until status is terminal.

analyzeGreekTrends — Greece-specific electoral forecasting.

  • Loads active Greek agents (≥5 required), builds rich per-agent summaries.
  • Prompts InvokeLLM (claude_sonnet_4_6) as a Greek electoral analyst with an embedded 2026 political context brief.
  • Returns party_trends[] (current %, 6-month trajectory, threshold likelihood, voter profile, risk/opportunity), analysis_summary, key_findings[], volatility_index, undecided_pct, dominant_issues[], and a psychological_breakdown.

5.4 Sample prompt the LLM receives (illustrative)

You are a behavioral research AI. Simulate how a diverse population of
200 people would respond to the following scenario.

SCENARIO TYPE: Policy Proposal
SCENARIO TITLE: Subsidized EV leasing program — 2026 relaunch
SCENARIO DESCRIPTION: A government-backed scheme offering €150/month
leasing for EVs, targeting urban/suburban households earning under €40k.
Includes a €2,000 scrappage bonus for cars over 15 years old.

AGENT POPULATION SAMPLE:
- Eleftheria, 34 female, Athens, marketing manager, income: middle,
  politics: center_left, values: environment, fairness, progress...
- Giorgos, 61 male, Kozani, retired factory worker, income: lower_middle,
  politics: far_right, values: tradition, national identity, faith...
[ ... 198 more ]

Analyze how this population would realistically react. Consider their
demographics, values, political views, and personality.

Return a JSON object with:
- overall_sentiment
- approval_rate (0-100)
- results_summary (2-3 paragraphs)
- key_segments[] { segment_name, percentage, sentiment, reasoning }
- insights[] (4-6 actionable)
- top_supporters_profile
- top_opponents_profile
- predicted_behavior (buy / share / protest / ignore)

5.5 Sample returned JSON (illustrative, abridged)

{
  "overall_sentiment": "positive",
  "approval_rate": 58,
  "results_summary": "The proposal lands well with urban middle-class drivers under 45...",
  "key_segments": [
    {
      "segment_name": "Young urban professionals",
      "percentage": 31,
      "sentiment": "positive",
      "reasoning": "See EV as affordable, modern, green."
    },
    {
      "segment_name": "Rural older drivers",
      "percentage": 24,
      "sentiment": "negative",
      "reasoning": "No charging access nearby; EV viewed as an urban luxury."
    }
  ],
  "insights": [
    "Lead messaging with the scrappage bonus.",
    "Pair with a visible charging-infrastructure commitment.",
    "Target 30-44 suburbanites with affordability messaging."
  ],
  "top_supporters_profile": "Salaried 28-44, Athens/Thessaloniki, center voters.",
  "top_opponents_profile": "60+, rural, right-leaning, low institutional trust.",
  "predicted_behavior": "Urban uptake concentrates; rural uptake needs charging-rollout reassurance."
}

6. The Data Model (Entities)

All entities live under base44/entities/*.jsonc. Records carry built-in fields: id, created_date, updated_date, created_by_id.

AgentProfile — a simulated person

  • Demographics: name, age, gender, country, city, education_level, occupation, income_bracket, family_status, has_children.
  • Politics & religion: political_views, religious_views, religion_denomination, religious_practice_frequency, religion_influences_politics.
  • Psychology (psychological_profile): aggression, moderation tendency, authoritarianism, tribalism, conspiracy susceptibility, anxiety, trust in institutions, openness to change, economic resentment, nationalism.
  • Personality models: big_five_personality (OCEAN 1–10), moral_foundations (Haidt, 0–10).
  • Lived experience: emotional_triggers, life_trauma, financial_concerns, consumer_habits, media_consumption, core_values, personality_traits, recent_news_context.
  • Status: active | archived.

SimulationRun — one run

  • Input: title, scenario_type, scenario_description, agent_count (≤1000), target_demographics (optional), attachments.
  • Status: pending → running → completed | failed.
  • Output: results_summary, results_data (structured), insights, agent_ids, completed_at, notes.

Supporting entities

  • ScheduledSimulation — planned dates (Calendar tab).
  • AgentGroup — named cohort of agent IDs.
  • FilterPreset — saved demographic filters.
  • SavedComparisonView — saved side-by-side comparison of two runs.
  • ContactSubmission — marketing-site contact form entries (admin-only reads).
  • AuditLog — append-only admin action log. Admin read-only.
  • User — built-in; admins manage roles & invite users.

7. The Admin Console

src/pages/Admin.jsx renders a header and a horizontal tab bar; each tab mounts a focused component. The console is admin-only (non-admins see "Access Denied").

| Tab | Purpose | |-----|---------| | Dashboard | KPIs (active agents, completed/running sims, avg approval), demographic/political charts, agent-growth timeline, recent sims. | | Agent Profiles | Browse/filter/paginate agents, generate new agents, group management, bulk edit, CSV export. | | Simulations | The core workspace — create, run, view results, charts, exports. | | Sync Market | Governed commercial decision studies for creative, launch, pricing and segmentation. Legacy aliases: Lumen/Vantage. | | Sync Civic | Governance, policy and crisis-communications templates. Legacy alias: Seraph. | | Sync Elections | Governed electoral scenario studies with prospective validation and explicit non-polling claims. Legacy aliases: Dynamo/Forge. | | Calendar | Schedule simulations on a monthly grid. | | History | Filtered view of completed runs + CSV export. | | Analytics | Cross-sim charts + Greek trends heatmap. | | Compare | Side-by-side comparison of two runs with saveable views. | | Filter Presets | Manage saved filters. | | Contact Submissions | Read contact-form entries. | | Users | Invite users, list users, change roles. | | Audit Log | Review admin actions. |

Key UI components

  • AgentCountSelector — slider + presets (10/25/50/100/250/500/1000) for simulation size.
  • AgentFilterSelector — pick filter mode + demographics before running.
  • SimulationTemplatesModal — prebuilt scenario skeletons.
  • SimulationChartsPanel / DemographicBreakdownTable — per-sim visuals.
  • SimulationAgentResults — per-agent responses.
  • SimulationAttachments — upload/remove files (passed as LLM context).
  • SimulationExportMenu — PDF (with charts + embedded attachment images) and CSV.
  • SimulationNotesModal — annotate a simulation.

8. The Simulation Lifecycle (Step-by-Step)

  1. Create — Admin → Simulations → New Simulation → fill title, type, description, choose size, (optionally) attach files → record created at status pending. An AuditLog entry is written.
  2. Run — Admin clicks Run → AgentFilterSelector asks for mode/filters. On confirm: record marked 'running', audit logged, base44.functions.invoke('runSimulation', { simulation_id, filter_mode, agent_filters }) fires (fire-and-forget), and the UI polls every 3s for completion.
  3. Backend executes — pool selection → shuffle → slice → prompt → attach files → InvokeLLM → save structured results → status 'completed' (or 'failed').
  4. View — expandable card shows summary, segments, insights, supporter/opponent profiles, predicted behavior; charts and per-agent responses available.
  5. Export — PDF or CSV.
  6. Compare — two completed runs side-by-side; savable as a SavedComparisonView.
  7. Operations — Clone, Re-run, Add notes, Manage attachments, Delete (all audit-logged).

9. Security & Privacy

  • Row-level security (RLS): every operational entity owner-locks records — each user sees only their own agents/simulations; admins see all. ContactSubmission: any logged-in user may create, only admins read. AuditLog: admin read-only.
  • Access control: the console is admin-only. Auth check runs client-side in src/pages/Admin.jsx via base44.auth.me().
  • Auditability: every significant admin action (create/clone/run/delete simulation) is logged for traceability.
  • Attachments caution: files attached to a simulation are passed to the LLM as context — avoid attaching sensitive/PII material.

10. Extending the Platform

  • New scenario type: add the enum to SimulationRun.scenario_type, to the SCENARIO_TYPES lists in SimulationsTab/HistoryTab, and (optionally) a template in SimulationTemplatesModal.
  • New agent attribute: add to AgentProfile.jsonc; update the prompt + JSON schema in both createSimulatedAgents and runSimulation so the model fills and uses it; surface in AgentDetailPanel / charts.
  • New backend function: create base44/functions/<name>/entry.ts (Deno handler, authenticate with base44.auth.me(), use SDK). Invoke with base44.functions.invoke.
  • New integrations: prefer app connectors when available; otherwise secret-backed backend functions (use set_secrets first).

11. Frontend Conventions

  • src/App.jsx routes everything. Marketing pages wrapped in AppLayout; /admin stands alone; this page at /docs; unknown routes fall to PageNotFound.
  • Entity access uses the pre-initialized base44 client from @/api/base44Client (e.g. base44.entities.SimulationRun.list('-created_date', 50)).
  • Design tokens live in src/index.css (dark-first palette; Inter body / Space Grotesk headings); mapped in tailwind.config.js. Use token classes (bg-primary, font-heading) — no hardcoded colors.
  • Components are small and focused; each new component/page gets its own file. shadcn/ui from @/components/ui; icons from lucide-react.
  • Realtime updates are available via base44.entities.<Name>.subscribe() (currently polling is used for simulation completion).

Reflects the codebase as deployed.

Synachron uses privacy-friendly product analytics to understand which workflows are useful. Tracking starts only after you allow it, and IP-based geolocation and session replay are disabled.

Support