What it is and how to use it.

Synthetic Users v1.1.1 turns one smart input into a decision memo: what people understand, what they doubt, where trust breaks, and what to fix before real traffic hits.

What changed in v1.1.1

• Cleaner report shell: verdict card, why stack, persona consensus, diagnostic bars, and next-move snapshot.
• Shareable reports: every saved memo can be opened by link without forcing the viewer through the run flow.
• Share on X: reports now create short X-ready copy plus a visual preview card for the linked memo.
• Open-world answers: broad questions now show a big answer first, then alternatives and an abstained/unclear split.
• Open-world cards: shared cards now show the modeled leader, other live options, and percentage split.
• Site mentions: when a public site clearly links its official X profile, shared reports can mention that account.
• More specific evidence: reports lean harder on visible page signals, Web search, token facts, X profile signals, and the exact brief instead of generic feedback.

Core promise

• Paste almost anything: a CA, URL, X profile, launch post, token idea, pricing page, onboarding copy, rough brief, or open-world question.
• One input is enough. The product decides the analysis lane instead of forcing a form.
• The output is a decision memo, not a soft AI review.
• Reports stay honest about uncertainty instead of pretending every answer is final.

Analysis lanes

• Product Surface Simulation: landing pages, apps, onboarding, pricing, docs, and copy.
• Token / CA Simulation: Base token pages, market surface, launch narratives, and early holder psychology.
• X Profile Simulation: account positioning, pinned narrative, trust signals, social proof, and what the feed communicates.
• Launch Brief Simulation: raw ideas, launch posts, product claims, token concepts, and early narrative tests.
• Open-World Decision Simulation: cars, software, sports, family, markets, crypto, and general questions with domain-specific lenses.

What a memo includes

• Verdict: the short read on whether the thing works, almost works, or leaks trust.
• Score: modeled reaction strength, not a promise of market performance.
• Why stack: the few signals that moved the result.
• Persona consensus: which synthetic evaluators leaned in, stayed unsure, or rejected the surface.
• Diagnostic bars: quick read on clarity, proof, friction, specificity, and trust.
• Next move: what to fix first instead of a vague pile of suggestions.
• Share pack: report link, X-ready copy, and visual card preview.

Open-world answer format

Open-world questions are answer-first. The memo shows the modeled leader in large type, then the strongest alternatives and an uncertainty split.

• Leader: the current best answer given available signals.
• Other live options: credible alternatives still in the race.
• Abstained / unclear: the share of uncertainty the model refuses to fake away.

Shareable report cards

Saved reports are built to travel. A shared memo carries short copy and a visual card so the result can be understood in a feed without dumping the whole report into a post.

• Site, token, X profile, and brief reports use a verdict-card layout.
• Open-world reports use a modeled-answer layout with percentages and alternatives.
• If the analyzed site clearly exposes an official X profile, the share copy can mention it.
• Shared copy is intentionally short. The card and memo carry the context.

Integrate it on your own server

Synthetic Users can sit behind your own product as a private analysis layer. Run it on your server, wire your own model/search/on-chain providers, and keep your keys in server-side environment variables. Never expose provider keys in browser code.

// server-side example
// POST /api/synthetic-users
{
  "input": "https://your-product.com/pricing",
  "mode": "auto",
  "audience": "founders, traders, skeptical buyers"
}

// minimal Node adapter shape
import express from 'express';
import { runSyntheticSimulation } from './synthetic-users/engine.js';

const app = express();
app.use(express.json());

app.post('/api/synthetic-users', async (req, res) => {
  const result = await runSyntheticSimulation(req.body.input, {
    webSearchKey: process.env.WEB_SEARCH_KEY,
    baseRpcUrl: process.env.BASE_RPC_URL,
    xApiKey: process.env.X_API_KEY,
    saveReports: true
  });

  res.json({
    verdict: result.memo.verdict,
    score: result.memo.score,
    nextMove: result.memo.rewriteNext?.[0],
    shareUrl: result.share?.url
  });
});

• Keep it server-side: provider keys, RPC URLs with credentials, and private analytics stay on your backend.
• Use your own providers: Web search, Base/on-chain data, social data, and model routing can be swapped for your stack.
• Store reports yourself: save memo JSON and generated cards in your database/object storage.
• Gate access however you want: token holding, account login, API key, credits, or internal-only usage.

Privacy and safety

• Use public inputs or information you are comfortable testing in beta.
• Do not paste private customer data, unreleased financial details, wallet secrets, API keys, or internal credentials.
• Reports are generated from the submitted input and public-facing signals where available.
• Synthetic Users is not an ad network, identity graph, or data resale product.
• A score is a modeled reaction signal, not financial advice, legal advice, or a guarantee.

How to use it

1. Paste one input.
2. Run the simulation.
3. Read the verdict, consensus, and next move.
4. Share the report if it is useful.
5. Fix the highest-leverage issue before spending more traffic.