Unsame is live at unsame.io. It is a Playbook Engine: before your model writes a post, a reply, a script or a changelog, Unsame tells it how to approach this one — and it will not hand out the approach you just used.

It does not write your text. Your model, with your key, still does that. Unsame decides the approach, from your own list, with real randomness and a memory of what was already used.

The problem it solves

Give an LLM a job that repeats — a daily post, replies to mentions, weekly scripts, outreach, support answers — and within days every output has the same shape. A longer prompt does not fix it. "Be creative" does not fix it. Raising the temperature shuffles the words inside one approach and never moves the model to another one.

This is a property of the models, not of your prompt. Alignment training narrows a model toward a few typical answers (Verbalized Sampling calls it mode collapse), and a model asked to pick at random cannot supply the randomness that would take (String Seed of Thought). So the choice of approach has to happen outside the model. That is the whole product.

How it works

You call Unsame once per generation with the input: the post you are answering, the mention, the event, or nothing at all for a planned slot. It returns a protocol, a short block you put into your model's prompt:

text
Situation: reacting to someone's post.
Engage with:
- they claim local models can't do agentic coding
- their one run looped for an hour
Approach: quote their point, add the missing angle, end with a question back
Form: length: short; opener: statement
Voice: casual, concrete, no emojis
Never: politics, competitor names
Do not repeat: hot_take (2 of the last 10)

That is an illustrative example. Every protocol carries the same parts:

  • Situation and hooks — which of your situations this input is, and the specific points the text must engage with. This is what keeps output from going generic.
  • Approach and form — one of your approaches that fits, drawn with OS entropy, with recently used ones penalised. Within a scope, no approach-and-form combination repeats in the recent window while an unused one exists.
  • Voice, always, never — copied verbatim every time. They are never varied, learned away or retired.

Your model writes the text. You report what happened — chosen, rejected, an edited ratio or a reward — and the engine weights the approaches that work for you. Reporting is always free.

Your playbook, your rules

A playbook holds your goal, voice, always and never rules, your situations and your ways (the approaches you accept for each). Unsame varies only the choice among them.

You don't start from a blank page: seed a playbook from one sentence, then edit it like a file. Every write is a numbered version. Pin a way to exempt it from anti-repeat, or ban one so it is never drawn. Learning is per goal and opt-in: off keeps the playbook exactly as written, propose suggests new situations and ways for you to accept or reject, and auto trials them on a small share of draws. The learner never edits your nodes.

The full format is in the playbook docs.

No generative model on the hot path

Judgments like "which situation fits" are typed yes/no and choice questions answered by Jev, a model that cannot write a sentence. Selection is plain math over your playbook. If the judge is unavailable after one retry, the API returns 503 judge_unavailable — never a silently random or keyword-matched approach.

Connect in a minute

From an AI assistant, no code. Unsame runs two remote MCP servers behind OAuth 2.1, so there are no keys to paste. In Claude Code:

sh
claude mcp add --transport http unsame-engine https://unsame.io/mcp/engine
claude mcp add --transport http unsame-author https://unsame.io/mcp/author

Run /mcp, pick each server and choose Authenticate. The engine server is what your agent calls before and after writing; the author server edits playbooks from chat. Codex CLI, Claude Desktop, claude.ai, ChatGPT and Cursor work too — steps for each are in Connect.

From your backend. One call per generation, then put draws[0].advice into your model's prompt:

sh
curl -s https://unsame.io/v1/advise \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"goal":"indie_dev_x","scope":"acct:me","input":{"text":"…what you are reacting to…"},"facts":["…"],"k":1}'

TypeScript (@unsame/sdk) and Python (unsame) clients handle the token for you. The rest is in the HTTP API docs.

Pricing in one line

One credit is one draw. That is the only number you need to predict a bill. The free plan has monthly credits and needs no card. Paid plans add included credits, overage with a spend cap you control, and auto learning; prepaid packs are there if you prefer no subscription. Reporting, reads, stats, export and validation are free on every plan. Details on Pricing.

What we don't claim

We don't promise more engagement, and there are no lift numbers here because we have not measured them on real accounts yet. What we claim is the mechanism: a different approach each time, grounded in the input, in a fixed voice. You can check it yourself — paste an input into the live demo and press the button three times.

Try it

Sign up with an email, no card. Pick one repeated writing job where the output has gone flat, run it through Unsame for a week, and tell us how it went at hello@muvon.io.

For the longer story of why we built it, read the launch post on the Muvon blog.

— Don