Give your agent an API key,
then ask it to simulate reactions.

Official skill

The official skill tells your agent when to use the API, how to collect context, how to poll results, and how to report raw voices without replacing the API with casual guessing.

Install the official Yomira skill from this GitHub repo:
https://github.com/ryuzo-k/yomira/tree/main/skills/yomira

After installing, use it whenever I ask you to simulate reactions to a message, post, landing page, offer, pricing page, product idea, or decision option.

If I provide a Yomira API key, call the real API. Do not replace it with casual reaction prediction unless I explicitly ask you not to use the API.

Agent onboarding

Yomira can be created from a terminal-capable AI agent. The user still owns the email, password, and API key. The agent can prepare the request, run the signup call, install the skill, and verify the API.

If your agent supports MCP, connect it to the Yomira documentation MCP server at https://docs.tryyomira.com/mcp. Use it to search setup instructions, API parameters, examples, and best practices before calling the Yomira API.

For the shortest flow, open Agent Start and paste the setup prompt into Claude Code, Codex, Cursor, Hermes Agent, or another terminal-capable agent.

curl -s -X POST "https://tryyomira.com/api/auth/register" \
  -H "content-type: application/json" \
  -d '{
    "name": "Your Name",
    "email": "you@example.com",
    "password": "choose-a-long-password",
    "companyName": "Your Company",
    "companyUrl": "https://example.com",
    "role": "Founder",
    "intendedUse": "I want to simulate reactions to messages, content, landing pages, and product ideas."
  }'

The response includes apiKey, credits, and user. Store the API key as a secret, then install the Yomira skill and use the setup prompt below.

npx -y github:ryuzo-k/yomira init --api-key sim_YOUR_KEY --target all --with-mora
npx -y github:ryuzo-k/yomira doctor

Agent setup prompt

Copy this into your AI agent after replacing sim_YOUR_KEY with your dashboard API key. This is the easiest way to make the API usable without writing code yourself.

You can use Yomira for reaction simulation.

API base URL:
https://tryyomira.com

API key:
sim_YOUR_KEY

When I ask you to simulate reactions, do this:

1. Identify the exact artifact people will see. If the artifact is missing, ask me for it.
2. Build a context packet from the current conversation: objective, audience, channel, sender/company context, desired action, known concerns, and alternatives.
3. Call POST /api/simulate with:
   - objective
   - artifact.type
   - artifact.content
   - audience.description
   - simulation.mode: "fast" for first pass, "standard" for serious decisions
   - simulation.target_n: 40 for first pass, 120 for serious decisions
4. Poll GET /api/simulations/{simulation_id} until completed.
5. Show me:
   - simulation_id
   - reaction distribution
   - representative raw voices
   - the concrete decision implications
   - what should be tested or changed next
6. If there are multiple candidate options, simulate each option instead of guessing.
7. Never replace the API with your own casual reaction prediction unless I explicitly ask you not to use the API.

Example asks

• Message decision — "Use Yomira to compare these three DMs and tell me which one I should send."
• Content preflight — "Simulate how AI founders and agency owners will react before I publish this post."
• Landing page — "Run a standard simulation on this LP and show what makes people trust or distrust it."
• New business idea — "Simulate the buyer reaction to this product concept and separate curiosity from willingness to pay."
• Mora flow — "Use Mora to map the options, then simulate every concrete option with Yomira."

API quickstart

The API is asynchronous. Create a job, poll until it completes, then download JSON or Markdown.

export YOMIRA_API_KEY="sim_..."

curl -s -X POST "https://tryyomira.com/api/simulate" \
  -H "content-type: application/json" \
  -H "x-api-key: $YOMIRA_API_KEY" \
  -d '{
    "objective": "Decide whether to publish this content.",
    "artifact": {
      "type": "content_draft",
      "content": "Paste the actual text people will see."
    },
    "audience": {
      "description": "Describe who will see this, where they see it, and what they already believe."
    },
    "simulation": {
      "mode": "fast",
      "target_n": 40,
      "max_agent_voices": 8,
      "max_output_tokens": 30000
    }
  }'

curl -s "https://tryyomira.com/api/simulations/SIMULATION_ID" \
  -H "x-api-key: $YOMIRA_API_KEY"

Response shape

• status — queued, running, completed, or failed.
• result.reaction_distribution — percentages and counts by reaction type.
• result.voice_clusters — grouped private voices and deeper patterns.
• result.agent_voices — representative individual simulated voices.
• downloads — Markdown and JSON export URLs after completion.
• credits_charged — credits used by the simulation.

Exports

Use exports as durable context. Paste them back into Claude Code, Codex, Cursor, your team chat, or your own internal decision docs.

curl -s "https://tryyomira.com/api/simulations/SIMULATION_ID?format=markdown" \
  -H "x-api-key: $YOMIRA_API_KEY"

Modes and credits

Context quality

The API gets better when the agent sends the exact artifact, the audience, the channel, the sender/company context, the desired action, and known worries. Thin context produces generic voices. Good agent usage should build a context packet before calling the API.

Context-first simulation

Yomira is designed to be used inside an AI agent that already has the user's working context. The agent should extract context from the conversation, files, docs, product notes, launch notes, customer notes, and Mora candidate paths before it calls the API. If the context is thin, the agent should ask 1-3 missing questions instead of running a generic simulation.

• Described — the user or agent describes the audience. This is the fastest self-serve mode.
• Context-enriched — the agent adds company, channel, product, pricing, proof, and known worries from the user's workspace.
• Grounded — the simulation uses real source material: CRM rows, customer notes, interviews, reviews, X/social data, community posts, or supplied audience examples.
• Calibrated — predictions are compared with real outcomes and corrected by use case over time.

Simulation method

The current self-serve engine is an LLM-backed synthetic voice simulator. It builds a context packet, creates audience agents from the described population, generates private reactions in parallel batches, and reduces those voices into distributions, clusters, representative voices, and exports. This is useful for fast decision support, but it is not yet the final form of the technology.

• Level 1: Described audience — the current default. The user or agent describes who should react.
• Level 2: Context-enriched audience — the agent adds company context, channel context, prior conversation, docs, and customer hypotheses before calling the API.
• Level 3: Grounded audience — the simulation is built from uploaded CRM rows, customer lists, reviews, interview notes, X/social data, community posts, or other source material.
• Level 4: Calibrated audience — synthetic outputs are compared against real survey/interview outcomes, then adjusted by segment and use case.

Enterprise

Self-serve credits are for fast synthetic preflight checks. Enterprise work is for grounded and calibrated simulation: Yomira helps construct the required audience dataset from CRM data, X/social data, customer lists, reviews, interviews, private context packs, and market source material.