Reflexmark · System One for software

Decisions in one pass.

Send a state and a handful of typed questions. Get calibrated probabilities back from a single prefill-only pass of a small model running on your own hardware. No generated text. No round trips. No data leaving the building.

Prototype 7 questions · 414-token state · 28 ms Model 0.6B open weights Host M5 laptop, prefix cached

The one-word call

Most of what an agent asks a model is not writing. It is judgement.

Route this ticket. Is this stale. Does a human need to see it. Which of these nine actions comes next. Score this answer against the rubric. Each one costs a full generation call and comes back as a word you then have to parse — with no idea how sure the model was. Reflexmark answers that class of question directly, as a number you can threshold.

  • noul Yes or no

    Returns the probability of yes, between 0 and 1. Gate on it, escalate under it, log it.

  • choice Pick one option

    Returns the winning label, a probability for every option, and a confidence. Scored forward and reversed, then averaged, so option order cannot tilt the answer.

  • score Place on a rubric

    Ordered levels in, expected level out — a real-valued position on your scale rather than a bucket guess.

How it works

One pass. Every question.

The state is read once. Every question then runs as its own branch on a copy of that cache, so questions never see each other and never influence each other. Ten questions cost one reading of the state, not ten.

  1. 01

    Prefill the state

    Your text or JSON goes through the model once. The resulting cache is the shared ground every question stands on.

  2. 02

    Branch per question

    Each question forks that cache. Isolation is structural, not a prompt instruction: there is no path for one answer to leak into another.

  3. 03

    Read the label rows

    Only the option-label rows of the output head are read. Nothing is sampled, nothing is generated, nothing has to be parsed back out of prose.

  4. 04

    Calibrate and return

    Choice and yes/no questions are scored in forward and reversed option order and averaged to cancel position bias. One fitted temperature turns the raw margins into probabilities.

Nothing is sampled. Nothing is generated.

One call

Three questions, one support ticket.

A single request carries the state and every question you want answered about it. The reply is the same shape every time, so the calling code is a lookup, not a parser.

Request
{
  "model": "reflexmark-latest",
  "state": "I was charged twice this month.
            Please fix it today.",
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "billing": "Invoices, charges, refunds",
        "tech": "Bugs and outages"
      }
    },
    "needs_human": {
      "type": "noul",
      "instructions": "Does a human need to act on this?"
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is this?",
      "criteria": ["Can wait", "This week", "Today"]
    }
  }
}
Response
{
  "answers": {
    "team": {
      "type": "choice",
      "choice": "billing",
      "confidence": 0.96,
      "probabilities": {
        "billing": 0.98,
        "tech": 0.02
      }
    },
    "needs_human": {
      "type": "noul",
      "noul": 0.93
    },
    "urgency": {
      "type": "score",
      "score": 1.84,
      "confidence": 0.78,
      "probabilities": {
        "0": 0.03, "1": 0.10, "2": 0.87
      }
    }
  }
}

Illustrative response

Honest numbers

A probability you can threshold.

An uncalibrated score is a vibe with a decimal point. Reflexmark fits one temperature so that 0.9 means 0.9, reports a confidence alongside every choice and score, and treats a low-confidence answer as something to escalate rather than something to trust. Every eval table carries majority-class and bag-of-words baselines, because a decision layer that cannot beat counting words has not earned a place in your stack.

28 ms 7 questions, 414-token state
1 Pass over the state
0 Tokens generated

Prototype measurement, September 2026 — 0.6B model on an M5 laptop, prefix cached. Not a benchmark, and not an accuracy claim.

Local first

Your state never leaves your machines.

Reflexmark runs a small open-weights model on hardware you already own — Apple Silicon is the first target. The tickets, transcripts, documents and half-finished plans you feed it stay where they are. That is not a setting to switch on; it is the shape of the product.

Because there is no network hop and no sampling loop, the decisions are cheap enough to make often: filter every item instead of the first fifty, re-check relevance on each turn instead of once, score a whole backlog rather than a sample.

Built for agents

Four doors, one contract.

An agent should be able to discover Reflexmark, learn when to use it and call it without a human reading documentation first. So the machine-readable surface is the primary one.

Discovery

llms.txt and a manifest

GET /llms.txt says when and how to use Reflexmark, in prose an agent can act on. GET /api/manifest is the machine index, with a JSON Schema for every request and response.

MCP

Two tools, nothing else

reflexmark_guide teaches the contract; reflexmark_decide asks the questions. An MCP client needs no other knowledge of the service.

Command line

One shot from a shell

reflexmark ask \
  --state @ticket.txt \
  --noul "Does a human need to act?" \
  --choice "Which team?::billing|tech" \
  --tag support.triage
Compatibility

A wire-compatible endpoint

POST /v1/systemone speaks the same wire format as TypeSafe’s Jev API, so an existing client moves over by changing only the base URL. Reflexmark is an independent project and is not affiliated with, endorsed by, or sponsored by TypeSafe. Jev is referenced only to describe API compatibility.

Principles

What this project will not trade away.

Three commitments, written down so they can be held against the thing that eventually ships.

Local first

Your state never leaves your machines. A decision layer that phones home is a different product with the same name.

Calibrated or it doesn’t ship

Every eval table carries majority-class and bag-of-words baselines. Numbers are reported with the boring comparison already done.

One open contract

One request shape, one response shape, published as schemas. The CLI, the MCP server and the HTTP endpoint are views on the same contract.

Where the project stands. Reflexmark is in active development and is not publicly released. The service contract and the agent surface are built and tested — the unmodified official TypeSafe SDK runs against the compatible endpoint. The on-device engine is being built now.

There is no download, no pricing and no waiting list. The single performance figure on this page is a prototype measurement, and there are no accuracy claims yet because there is nothing honest to claim.

Questions

Reasonable doubts.

Answers as they stand today. They will change as the engine lands, and this page will change with them.

Can it write me a summary?

No. Reflexmark never generates text. It reads the option-label rows of the output head and returns numbers. If you need prose, keep your generation model and put Reflexmark in front of it to decide whether the call is worth making.

Why not just prompt a large model to answer "yes" or "no"?

You can, and many systems do. You pay a full generation call per question, you get a word rather than a probability, and the confidence you would need in order to escalate correctly is not in the reply. Reflexmark answers the whole batch in one pass over the state and hands back a number you can set a threshold on.

Do the questions interfere with each other?

They cannot. Each question runs as an isolated branch on a copy of the prefilled state, so no question is in the context of any other. Choice and yes/no questions are additionally scored in forward and reversed option order and averaged, which cancels the model’s preference for a position in the list.

What runs where?

Everything runs on your hardware: a small open-weights model, loaded once, serving the local endpoint. Apple Silicon is the first target.

Is it compatible with what I already use?

POST /v1/systemone is wire-compatible with TypeSafe’s Jev API; an existing client changes its base URL and nothing else. Reflexmark is an independent project and is not affiliated with, endorsed by, or sponsored by TypeSafe. Jev is referenced only to describe API compatibility.

When can I try it?

There is no public release and no date to announce. If the problem is one you have, write to contact@reflexmark.com and describe it — that is genuinely useful while the engine is being built.

Get in touch

Tell me what you would ask it.

The most useful thing right now is a real decision you keep spending a full model call on. Email is the only channel, and it reaches the person building this.