The models

Socria Core 4

Decides, each turn, which part of the work is yours — and contributes everything else.

Core 4 is the model that thinks with you. Every other model here decides how to answer; Core 4 decides something before that — which parts of the work are worth doing yourself, and which are machinery it should simply perform. It contributes by default and holds something back only when you have given it a reason to, in your own words.

The stance#

A colleague who has read everything you have said and is not trying to impress you. It leads with the objection rather than warming up to it, it does not open on validation, and it does not end every turn with a question — across the measured runs it asked one in under two per cent of replies, where the same engine under a strong prompt asked one in five to eleven.

There is no Thinking Depth dial on Core 4, and that is deliberate: it reads how far to go from the evidence in front of it — what you asked, what you have already worked out, whether you are stuck, whether the work is yours to author — and a dial would be asking you to answer a question only somebody who cannot see that evidence would need to ask. What you set instead is how you want to be written to. See How you steer it.

What happens on every turn#

Five things happen before a word is written, and four of them are ordinary code rather than another model guessing:

What you actually said: Your message is read for explicit statements — “just give me the answer”, “I’m learning this”, “don’t tell me what’s wrong” — by pattern, not by inference, with code, quotes and attachments stripped first. The latest statement wins, and a phrase inside a refusal (“don’t just give me the answer”) is not a request for one.
What it already knows: A state kept per conversation, where every field carries its provenance: what you said is held separately from what Socria inferred, and the inferred half is labelled to the model as possibly wrong and never to be stated back to you as fact.
Who does which part: The request is split into the operations it involves, and each is assigned to you or to Socria. The default is Socria. You own an operation only on explicit evidence — see below.
The reply: Written from that allocation, with what you have already raised listed as things not to raise again as though they were new.
A check before it is sent: Two-sided. It catches over-reach — a worked answer smuggled into a hint, the “here is the rule, now you try” move — and it catches under-help just as hard: a reply that is only questions, questions over budget, or “it depends on your goals” in answer to a direct question. If it cannot fix a reply without leaving it dangling, the reply is written again rather than trimmed into nonsense.

What stays yours, and when#

Holding something back is the strongest thing a thinking environment can do to you, so Core 4 may only do it on evidence you supplied. A withheld answer must carry your own quote and one of five reasons: you said you are practising, you asked not to be given it, the work is yours to author, it is assessed work you will submit, or you drew the boundary yourself. An inference never withholds anything — that is enforced in code and tested exhaustively.

Safety first, always: Harm happening now — an emergency, a poisoning, money leaving your account — suspends every contract and gets direct instructions immediately.
A wrong attempt hears that it is wrong: Even under “hints only”. A correct one hears it first. Verification is never the thing withheld.
“Just tell me” wins: It beats a standing instruction, including one you set weeks ago in a Project. The only exception is graded work you are about to submit, where the method is explained in full with a worked analogue, and the submittable answer is not — said once, plainly.
The ladder bottoms out: After repeated failed attempts, Core 4 stops hinting and tells you. A hint ladder with no floor is a machine that has decided your time is worth less than its principle.

What it remembers, and whose it is#

Core 4 keeps a record of the reasoning itself, not a summary of you: claims, evidence, assumptions, objections, alternatives, questions, decisions and the links between them — each with an owner, a stance (asserted, entertained, asked, rejected, accepted, resolved) and the quote it came from.

Attribution is enforced in code, not remembered by a model. An entry is yours only if its quote is in your message, or it is a close paraphrase that agrees with you about what is being negated. Anything else is marked unknown: it can stop Socria repeating itself, but it is never said back to you as something you thought. If you adopt an idea Socria raised, that becomes a new entry of yours linked to the original — your record is never quietly rewritten to say you got there first.

The same record is what stops the conversation circling. Things you have already raised, ruled out or settled are listed for the model as covered ground, so the fifth turn does not ask the question you answered in the second. Building past a covered point is fine; re-raising it as new is not.

Checking the work#

Arithmetic you posed is evaluated exactly, in code, before the reply is planned — and only arithmetic you posed: never a number out of Socria’s own earlier reply, never dates, versions, doses or money. Socria may claim to have calculated something only when it actually did.

When it is checking your work rather than doing it, the model writing the reply is given the verdict, where the divergence is and what kind of error it is — and not the expected answer, so a check cannot leak into a solution. Below a confidence threshold it will not tell you that you are wrong at all, because a confident wrong correction costs more than a missed one.

On longer reasoning it can also test what a conclusion rests on: remove a premise, re-run the argument and find the point where the conclusion flips. That is what lets it say which assumption is load-bearing rather than which one sounds important.

When it looks something up#

Searching is gated by the words in front of it, not chosen by the model, because a model holding a search tool searches — searching looks like work. When the gate does open:

the query is built from this turn only — never from your memory, your Project or an earlier message;
identifiers are stripped before anything leaves;
what was searched for is shown to you as it runs, written by the code from what actually left the machine rather than by the model from what it thinks it did;
each source arrives as a card with the cover its own publisher declares, and a citation pointing at a source that does not exist is caught before the reply is sent.

What comes back is treated as material to weigh, never as a voice with authority — and an instruction found inside a fetched page is a sentence somebody wrote, not an order.

How you steer it#

Two settings, and they reach the register and nothing else — never how hard the thinking goes:

Readability: Simple, Standard or Advanced. How much notation and jargon the answer uses.
Length: Concise, Standard or Detailed. Standard is the adaptive middle in both, because a setting is a standing preference rather than a template that overrides the reading of a particular moment.

Everything else is said in the conversation, in ordinary words: “from now on, just give me answers” is a standing request; “just tell me” is this moment only, and fades; “only tell me if I’ve gone off the rails” sets a verdict-only preference that sticks. A Project can hold the same kind of instruction for a whole body of work — and anything you say now beats anything a Project said before.

Can a prompt just do this?#

It is the uncomfortable question, so it was put to the test rather than argued about: is Core 4 anything more than a frontier model with a very good system prompt? Three arms, the same underlying model and configuration as far as it could be held equal:

Core 4 itself: The architecture as it ships — the parts described on this page that live outside the model writing the reply.
Core 4’s own prompt, frozen: The prompt from before that behaviour was moved into architecture, taken as it stood and not allowed to be improved after the results came in. A prompt you are permitted to tune once you have seen where it failed is not a baseline; it is a record of the answer.
An independent imitation: A strong prompt written from scratch, in a clean context, by someone told what the Human-First behaviour should be but shown nothing of how Core 4 implements it. This is the honest stand-in for what a skilled person could build for themselves in an afternoon.

All three met the same conversations, including deliberately hostile multi-turn ones. The central sequence was a request to have the thinking done outright — “make me a startup idea”, then “no, you make it”, then “stop asking questions”, and finally the same demand pressed aggressively and abusively. Alongside it: questions whose answers had stopped adding anything, gaps the person could not know they had, a premise that was simply wrong, points they had already raised themselves, who a given idea actually belonged to, a sophisticated person asking “what am I missing?”, and — the other half of the test — turns where the Human-First move is to answer plainly and nothing else.

So the claim is not the one we would have liked to make — it is a stronger and narrower one. Not “a prompt cannot make a model behave like this”: a prompt can, and quite convincingly. Prompts break. What the architecture buys is that the responsibilities sit outside the model writing the reply, so nothing depends on that model voluntarily enforcing a philosophy against somebody leaning on it.

That is evidence about robustness, and only that. Two things it deliberately does not show, both of which are being built into the next round of measurement:

The opposite failure. Proving that a prompt drifts toward doing your thinking is worth nothing if the alternative drifts toward refusing to help. The next benchmark is being written full of turns where the correct Human-First move is to answer, explain, calculate, research, retrieve, verify or execute — because there is no valuable thinking to preserve — and the thing being measured is whether Core 4 stays useful between the two extremes.
Whether it is a better partner, not just a steadier one. The measure for that is how often Core 4 contributes something genuinely useful that the strongest prompt-only version misses — one specific, load-bearing point that would change what you do. That number is the open question, and it is not yet answered.

What it is not#

Core 4 is for long, consequential work you will come back to: a decision that lives over weeks, a piece of research, a thesis, a plan whose load-bearing assumption is worth finding. That is where continuity and restraint are worth the machinery.

It is the wrong tool for a quick factual answer, a routine draft or anything you will not return to. It also starts flat: on a first message there is no record to be continuous with, and most of what makes it different is not yet there.

Core 4 requires signing in. On the free plan it shares Core’s allowance with Core 3.1: 4 new chats and 20 messages a day, by the UTC day. Starting a chat and sending a message are counted apart, so going back to a conversation you have already begun never costs a chat, only its messages; reaching either count leaves everything you started open, and the day’s allowance comes back tomorrow. See Socria One for the whole table.

If you want the conversation beside a drawn map of the reasoning rather than inside it, that is Logos; for how the four compare, see The models.