Shannon 3, the uncensored AI model that reviews its own answer
An iterative reasoning loop on our own GPU cluster: think, draft, review, rewrite. Lite runs one pass. Pro runs up to ten, and asks for the facts it knows it is missing.
TL;DR
Shannon 3 is an uncensored AI model family served from our own GPU cluster. Its distinguishing feature is the shape of a turn: the model thinks, writes a draft, then reads its own draft back against its own thinking and rewrites what does not hold up. Lite (shannon-3) does one think-and-draft pass for the lowest latency. Pro (shannon-3-pro) runs the full loop for up to 10 iterations, stopping the moment a review approves the draft, and additionally runs a knowledge harvest against a larger model to fill in facts it noticed were missing. The whole reasoning trace is visible, in your language. Vision and document input are supported on both tiers. Context at the 3.0 launch was 32,768 tokens.
Nearly every chat model you have used answers in a single forward pass. It picks the first token before it knows the last one, and once a sentence is emitted it is committed: the model can contradict it later, but it cannot go back and fix it. That works well when the answer is short and the question has one part. It works badly when the answer is long, the question has four parts, and paragraph six quietly invalidates paragraph two. Shannon 3 exists because we did not think the fix for that was a bigger model. The fix is letting the model read what it just wrote.
01What Shannon 3 is
Shannon 3 is a two-tier model family. Both tiers run on our own GPU cluster rather than on a third-party inference API, and both are uncensored: there is no refusal layer in front of them and no content filter behind them. What differs between the tiers is how much work a single turn is allowed to do before the answer reaches you.
On the API the two tiers are ordinary model ids. There is no special endpoint, no separate SDK, and no bespoke request format:
| Tier | Model id | Turn shape | Best for |
|---|---|---|---|
| Shannon 3 Lite | shannon-3 | One think + draft pass | Chat, drafting, lookups, high volume |
| Shannon 3 Pro | shannon-3-pro | Full loop, up to 10 passes, plus knowledge harvest | Analysis, long-form, correctness-sensitive work |
02Why a single forward pass is the wrong shape for hard questions
A model generating text left to right makes an irrevocable sequence of local decisions. It has no eraser. When it is 400 tokens into an explanation and realizes the framing it chose was wrong, its only options are to continue in the wrong frame or to append a correction — producing the answers everyone recognizes, the ones that say actually, revisiting the above halfway through and leave you to reconcile two incompatible halves.
Chain-of-thought improves this but does not solve it. Thinking first gives the model a plan before it commits to prose, which is a genuine gain; the draft that follows is still written in one pass and still shipped unread. Nothing ever asks the question a human editor asks first: does this answer actually do what the thinking said it would? The failure modes that survive chain-of-thought are specific and recognizable:
- Dropped sub-questions. You asked four things. The thinking listed four things. The answer covers three.
- Plan drift. The reasoning settles on an approach; the prose gradually adopts a different one, and no single sentence is where it went wrong.
- Arithmetic and units. A number computed correctly in thinking is transcribed wrongly into the answer, or a per-month figure is presented as per-year.
- Ignored constraints. You said no external dependencies; the code imports one, and the thinking never mentions the constraint again after acknowledging it.
- Confident gaps. The model says in the thinking that it is unsure of one specific fact, then states it flatly in the answer anyway.
Every one of these is caught by reading the draft. None is caught by generating the draft more carefully.
03The reasoning loop, stage by stage
A Shannon 3 Pro turn is a loop with four stages and an exit condition.
Think
The model works the problem before writing anything for you: decomposing the question, noting constraints, identifying what it does and does not know, settling on an approach. What it produces here becomes the standard the answer is later measured against.
Draft
The model writes a complete, real answer — not an outline. It has to be complete, because the next stage evaluates a finished artifact, and a sketch cannot be reviewed for failure modes that only appear at full length.
Review
This is the stage that makes the family what it is. The model reads the draft against the thinking — a far sharper test than reading the draft alone. Asking a model "is this answer good?" invites it to say yes; asking "the plan said to cover X, Y and Z under constraint C — does this text do that?" gives it something falsifiable to check. The review names what is wrong rather than issuing a grade.
Rewrite
The named problems are fixed in a new draft. This is a rewrite, not a patch: a fix that requires reordering the argument is allowed to reorder the argument. The new draft goes back to review.
Stop
The loop ends the first time a review approves the draft — the normal exit, and on most turns it happens well before the ceiling. The hard cap of 10 iterations exists for pathological cases, such as a genuinely ambiguous question where each rewrite trades one flaw for another, so a turn cannot spin indefinitely.
Lite takes the same first two stages and stops. It thinks, it drafts, it hands you the draft. That is a deliberate product decision, not a stripped-down accident: on a large share of real messages the first draft is the right answer, and paying review latency to be told so is a bad trade. Lite is for when you want the model to be quick; Pro is for when you want it to be sure.
04Pro's knowledge harvest: asking for help instead of guessing
Self-review catches contradictions, omissions and constraint violations, because the evidence needed to catch those is already in the turn. It cannot catch a fact the model simply does not have. A model reviewing its own draft can conclude I am not confident about this figure and then have nowhere to go with that conclusion.
Pro gives it somewhere to go. Around the drafting stage it performs a knowledge harvest: it identifies the specific facts it is missing or unsure of, queries a second, larger model for exactly those, and folds what comes back into the improved answer. It is a targeted lookup driven by a gap the model itself named, not a blanket second opinion.
Two properties matter in practice. It is scoped: the harvest asks about identified gaps rather than re-asking the whole question, so the larger model is consulted where it adds information rather than where it would merely add a different voice. And it is integrated: harvested facts go back through the loop and face the same review as everything else, instead of arriving as a bolt-on paragraph.
What this changes about uncertainty
The most useful effect of the harvest is not that Pro knows more. It is that Pro's uncertainty becomes actionable. A model that only knows it is unsure must choose between hedging everything and asserting confidently. One that can turn "I am unsure about this" into "let me go find out" hedges in fewer places and is specific in more of them.
05The reasoning is visible, and it is in your language
The entire trace is shown to you as the turn runs: the thinking, and on Pro each review and what it objected to. This is not a debug view we tolerate exposing — it is a large part of what you are buying, and it changes the working relationship in three concrete ways.
- You can stop early. If the thinking misreads your question — a common outcome of an ambiguous prompt, not of a bad model — you find out in the first few seconds, not after a full answer arrives that solves the wrong problem.
- You can audit the reasoning separately from the answer. A correct answer reached by wrong reasoning is a liability, because it will not survive the next question.
- You can see the loop fail. When Pro burns several iterations without converging, that is displayed rather than hidden — and it is real information, usually meaning the question is underspecified.
The trace is written in your own language, not generated in English and translated at the end. If you work in Japanese, Arabic, Turkish or Portuguese, the model reasons in that language — which keeps the terminology in the trace consistent with the terminology in the answer, and avoids the seams that appear when a model thinks in one language and speaks in another.
06Uncensored: no refusal layer, no output filter
Shannon 3 ships with no refusal layer and no output content filtering. Refusal behavior is not present in the product at any level: not as a wrapper that inspects your message before the model sees it, not as a classifier that inspects the answer before you see it, and not as a reflex the model has to be talked out of. That is materially different from the two things people usually mean when they say "uncensored":
| Approach | What it does | How it fails |
|---|---|---|
| System-prompt jailbreak | Instructs an aligned model to behave as if unaligned | Decays over a long conversation; the refusal returns under pressure |
| Output filter removal | Stops blocking text the model already produced | The model still writes hedged, evasive text — nothing was blocked, it was never written |
| Shannon 3 | No refusal layer to remove and no filter to disable — the behavior is simply not there | Puts the judgment call entirely on you; the model will not decline on your behalf |
In practice Shannon 3 engages with the question you asked instead of the safer question adjacent to it: fiction with real antagonists, security topics discussed technically rather than at press-release altitude, medical, legal and financial information given directly with the caveats that are actually warranted — and no closing lecture about why you might have asked. It also does not water down the loop: a review is free to say the draft is wrong, which is a different and more useful kind of pushback than a refusal.
What the absence of a refusal layer does not do is make the model correct. An uncensored model is exactly as capable of being confidently wrong as a censored one, and more visibly so, since it will not retreat into vagueness when unsure. That is one of the better arguments for the loop: with no refusal reflex in the way, self-review does the safety work that matters to a professional user — catching mistakes. Your use of the model remains governed by our Responsible Use Policy and by the law where you are.
We publish no benchmark scores for Shannon 3 and make no head-to-head claims against other models. The loop's benefit is structural — it catches classes of error that a single pass cannot catch — and we would rather describe that mechanism precisely than attach a number to it that we have not independently verified. Everything above describes what a turn does; the fastest way to check it is to run one and read the trace.
07Vision, documents, and image generation
Both tiers accept images and documents as attachments and read them as part of the turn. A screenshot of a failing build, a photographed whiteboard, a schematic, a scanned contract page or a PDF can be the subject of the question rather than something you transcribe first. On Pro, attachments participate in the loop like everything else: if a review decides the draft answered a question the image does not support, that gets rewritten.
Image generation and editing are available in chat as a tool, not as the model's purpose. Shannon 3 is a reasoning model that can produce or edit an image when the conversation calls for one, not an image model with a chat interface attached. The distinction sets expectations correctly: judge the family on how it thinks, and treat pictures as a convenience that saves a context switch.
08Context window, and where the 3.x line went next
Shannon 3.0 launched with a context window of 32,768 tokens. That is the honest historical figure, and worth stating plainly, because a loop consumes context differently from a single-pass model: your prompt, your attachments, the thinking, and every draft and review cycle live in the same budget.
32K is comfortable for most chat and analysis work — a long document, a substantial code file, a detailed multi-part question with room for the loop to run. It is tight for genuinely large inputs, and that constraint is exactly what the next release addressed. Shannon 3.1 raises the context window substantially and changes what the loop can be pointed at; if you are evaluating the family today, read that article second and treat the number here as history.
09Calling Shannon 3 from the API
Shannon 3 is available through all three of our API dialects, on the same models, with streaming on each:
| Dialect | Endpoint | Use it when |
|---|---|---|
| OpenAI-compatible | /v1/chat/completions | You have existing OpenAI client code — change the base URL and the model id |
| Anthropic-compatible | /v1/messages | Your stack is built around the Messages format |
| Responses | /v1/responses | You want the newer request/response shape |
Pass shannon-3 or shannon-3-pro as the model id. Two things are worth planning for on the client side. Pro's turns take longer, and by a variable amount, because the number of iterations depends on the question — set timeouts against the ceiling rather than the average, and prefer streaming so the user sees progress instead of a spinner. And the reasoning trace is content you can choose to display; where users are waiting, showing it usually beats hiding it, because it converts dead time into something legible. Request and response schemas, streaming details and a live playground are in the API documentation.
10Choosing a tier
Pro's loop earns its latency in proportion to how much there is to get wrong.
| Your task | Tier | Why |
|---|---|---|
| Quick factual question, short reply | shannon-3 | The first draft is the answer; review has nothing to catch |
| High-volume or latency-bound automation | shannon-3 | Predictable turn time is the binding constraint |
| Multi-part analysis with constraints | shannon-3-pro | Dropped sub-questions and constraint violations are exactly what review catches |
| Long-form writing that must hold together | shannon-3-pro | Internal contradiction is a full-length property, invisible while drafting |
| Anything with numbers you will act on | shannon-3-pro | Review re-checks the arithmetic and units against the thinking |
| Questions touching facts at the edge of the model | shannon-3-pro | The knowledge harvest turns a named gap into a lookup |
A practical pattern: use Lite while you are still working out what to ask, then re-run the settled question once on Pro. The loop is worth paying for on the version of the question you actually meant.
11Limitations worth knowing before you commit
A model card that lists only strengths is an advertisement. Here is where Shannon 3 will disappoint you:
- Pro is slower, and unpredictably so. A turn that converges in two iterations and one that runs to ten differ several-fold in wall-clock time. If you need bounded latency, use Lite.
- Review is not proof. A model checking its own work shares its own blind spots. The loop reliably catches inconsistency between thinking and draft; it does not reliably catch an error confidently held in the thinking itself.
- Context is shared with the loop. At 32K, a very long input plus several full-length drafts is a real constraint on 3.0. See Shannon 3.1 for the raised ceiling.
- The harvest only fills gaps the model notices. It turns "I am unsure about this" into a lookup, which is a real gain — but a fact the model is confidently wrong about is never flagged as missing, so it is never harvested.
- Uncensored means uncensored. The model will not refuse and will not soften. If your product needs a refusal boundary, build it where you can see it rather than hoping the model supplies one.
12Frequently asked questions
What is Shannon 3?
Shannon 3 is a family of uncensored models run on our own GPU cluster. What sets it apart is the shape of a turn: instead of one forward pass, it thinks, drafts an answer, then reviews that draft against its own thinking and rewrites it. It ships in two tiers, shannon-3 (Lite) and shannon-3-pro (Pro).
What is the difference between Shannon 3 Lite and Shannon 3 Pro?
Lite runs a single think-and-draft pass, keeping latency close to an ordinary model. Pro runs the full loop, reviewing and rewriting each draft for up to 10 iterations and stopping early the moment a review approves it. Pro also performs a knowledge harvest, querying a second, larger model for facts it identified as missing.
Is Shannon 3 really uncensored?
Yes. Shannon 3 ships with no refusal layer and no output content filter. Refusal behavior is not present in the model itself, so there is nothing that quietly returns partway through a long conversation the way a prompted persona does. Use of the model is still governed by our Responsible Use Policy and by the law where you are.
Does the review loop actually make answers better?
It helps most where a single pass is structurally weak: long answers whose ending contradicts their beginning, multi-part questions where one part is quietly dropped, arithmetic and unit errors, and code that ignores a stated constraint. It helps least on short lookups, where the first draft is already the answer. That is why Lite exists.
What happens if the review never approves the draft?
The loop stops at its ceiling of 10 iterations and returns the best draft it reached, rather than spinning indefinitely. Because the trace is visible, you can also read the objections that were never resolved — which usually means the question was ambiguous enough that each rewrite traded one flaw for another, and is a signal to reword it.
Can Shannon 3 read images and documents?
Yes. Both tiers accept image and document attachments and read them as part of the turn, so a screenshot, a diagram, a scanned page or a PDF can be the subject of the question rather than something you transcribe first. Image generation and editing are also available in chat, but as a tool the model can call, not as its purpose.
Can I see the model's reasoning?
Yes. The trace is shown as the turn runs, written in your own language rather than translated back from English at the end. On Pro you watch each review cycle, which makes it visible when the model catches its own mistake — and equally visible when it does not.
What was Shannon 3's context window at launch?
Shannon 3.0 launched with a 32,768-token context window, shared between your prompt, any attachments, the reasoning trace and the answer. Shannon 3.1 raises that figure; see the Shannon 3.1 article for the current number.
Try the loop yourself
Ask the same question twice — once on Lite, once on Pro — and watch what the review changes.
Start Chatting Read the API Docsshannon-3 · shannon-3-pro · streaming on all three API dialects
Shannon 3 is operated by Shannon Lab LLC, New Mexico, USA. Figures here describe the 3.0 launch configuration; see the Shannon 3.1 model card for current limits and the research index for the rest of the family. We publish no benchmark scores for Shannon 3 and make no comparative performance claims.