Terrapin Docs

Overview

An open large reasoning model that never stops learning.

Most AI models are frozen the day training ends. They can be remarkably capable, but they are fixed in place. Every conversation starts from scratch, and they cannot get better at the problems you actually bring them. Terrapin is built to work differently: it keeps learning after training, adapting as it thinks and remembering what worked across sessions.

Terrapin is a large reasoning model with its own architecture, the Tri-Timescale Plastic Transformer. It is built in the open, released for anyone to run, and designed for people who care about how a model actually works, not just what it outputs.

The idea in one paragraph

The most valuable thing a model can do is learn quickly, not just recall. Terrapin is built around that bet. Its connections adjust while it reasons, brain-inspired "plasticity" that lets it adapt to a problem as it works through it. A gated memory carries validated lessons from one session into the next, so it remembers what worked and gets better at the problems you use it for. And a reasoning layer can show the actual steps behind an answer, so you can follow why it reached a conclusion.

What makes it different

Terrapin runs on three timescales at once, where a normal model has one fixed set of weights:

• Slow weights hold stable, trained knowledge.
• Fast weights adapt in real time while the model thinks, then fade.
• Persistent memory carries validated lessons across sessions.

The result is a model whose defining strength is adaptation rather than raw size.

Explore the docs

• What Terrapin Is – the core idea, in plain terms
• How It Works – the architecture and the three timescales
• How It Learns – plasticity, memory, and continual learning
• Capabilities – what Terrapin is built to do
• Honest Roadmap – what is proven, what is ambitious, what is deferred
• FAQ – common questions answered plainly

Where the project stands

Terrapin is an independent, build-in-public project. The work is documented openly, including the parts that are hard and the parts that are still unproven. The goal is not to out-scale the largest labs, but to show that an open, learning-first model can be built outside them, and to keep it something anyone can run and understand.

What Terrapin Is

Terrapin is a large reasoning model built around one idea: a model should keep learning after training ends, not freeze in place.

The problem it addresses

Most AI models finish training and then stay exactly the same forever. They can be enormously capable, but they are fixed. Every time you talk to one, it starts from scratch with no memory of what worked before, and it cannot get better at the specific problems you bring it. All that intelligence is locked in place the moment training stops.

Terrapin is designed to work differently. It has brain-inspired connections that adjust while it thinks, so it adapts to a problem as it works through it. It has a memory that carries useful lessons from one conversation into the next, so it remembers what worked. And it can improve its own problem-solving over time, keeping the lessons that genuinely help and setting aside the ones that do not.

A way to picture it

Imagine a child who has learned to ride a bicycle. The first few wobbly attempts are hard, but something important happens along the way: the child is not just memorizing one exact bike on one exact street. They are learning balance, how to correct a lean, how to trust momentum. Later, when that same child steps onto a scooter or a skateboard for the first time, they pick it up far faster than they learned the bike, because the underlying skill carries over. They learned how to learn that kind of thing.

A frozen AI model is like a child who could ride only the one bike they trained on, and had to start completely over for every new bike, every new day, remembering nothing. Terrapin is built to be like the child who keeps the balance, carries it forward, and gets quicker at each new thing because of everything that came before.

What it is built on

Terrapin is initialized from a powerful open model and then trained into its own architecture and identity. Starting from a strong open foundation is what makes an independent, capable model possible on an independent budget. From there, its distinctive components, the plastic connections, the memory, the reasoning layer, are native to its design, and heavy retraining moves it into its own identity rather than leaving it a copy of where it started.

Who it is for

Terrapin is a general reasoning model, so anyone can use it. But it especially speaks to people who are curious about how a model works: its brain-inspired design, its inspectable reasoning, and the idea of a model that keeps learning. It is built and documented in the open for exactly that kind of curiosity.

How It Works

Terrapin's architecture is the Tri-Timescale Plastic Transformer. The name captures the core idea: a network that runs on three clocks at once, where a normal model has only one.

This page describes the shape of the design at a conceptual level. It is meant to explain how Terrapin works, not to be a build recipe.

Three timescales

A standard model has a single set of weights, fixed after training. Terrapin has three, each changing on its own schedule:

Slow weights hold stable, learned knowledge. They change only during training, warm-started from an open foundation and then trained into Terrapin's own identity. This is the deep, durable knowledge.

Fast weights change while the model is thinking. Inspired by how synapses strengthen when neurons fire together, they let Terrapin adapt to the problem in front of it as it reasons, then fade afterward. This is rapid, in-the-moment adaptation.

Persistent memory sits between the two. It carries lessons across sessions, but only lessons that have been validated as genuinely helpful. This is durable, compounding learning over time.

Stable long-term knowledge, rapid short-term adaptation, and validated lasting memory, each on its own timescale, in one model.

The main components

Terrapin's design brings together several parts that a standard transformer does not have:

Plastic transformer blocks. Every layer carries two pathways instead of one: the stable slow pathway, and a fast pathway that adapts during a single pass. The adaptation is woven into the model's computation, not bolted on afterward.

A neuromodulator, "the conductor." A dedicated part of the network decides when to adapt, when to engage careful step-by-step reasoning, and when a lesson is worth remembering. It is inspired by how the brain flags which moments matter. No standard model controls its own learning this way.

A symbolic reasoning layer, "the why." Alongside its neural intuition, Terrapin has a layer that can reason in explicit, inspectable steps and produce a derivation you can follow. This is what lets it show why it reached an answer, rather than only presenting the result.

Gated persistent memory. The durable store that carries validated lessons across sessions, so Terrapin remembers what worked and improves at the problems you use it for. A validation step decides what is worth keeping.

Adaptive expert routing. Terrapin is a mixture-of-experts model, meaning different parts of the network specialize. Its routing considers not just what a problem is about, but how much adaptation it needs, sending novel problems toward the more adaptable parts of the model.

Grounded in real science

The brain analogies here are not decorative. Plasticity, fast weights that strengthen with co-activation, and neuromodulation are all drawn from established ideas in neuroscience and machine-learning research. Terrapin's contribution is bringing them together in one model at a meaningful scale. Because this is genuinely ambitious, the roadmap is honest about which parts are well-established and which are still being proven.

How It Learns

Learning is the heart of what makes Terrapin different. This page explains how it learns, at three levels, and why the design keeps that learning safe and trustworthy.

Three kinds of learning

While it thinks (within a session). Terrapin's fast weights adjust as it works through a problem. Faced with something unfamiliar, it grows more oriented as it reasons, rather than applying fixed weights uniformly from start to finish. This adaptation is temporary; it fades when the session ends.

Across sessions (durable memory). This is where "remembers what worked" lives. As you use Terrapin over time, it can carry forward the approaches that succeeded, the way you like things done, the patterns that come up in your work. Because this memory persists, it stops treating every conversation as a blank slate and starts reflecting how you actually work.

Over time (improving itself). Terrapin can refine its own problem-solving as it accumulates experience, keeping the changes that genuinely help and setting aside the ones that do not.

Learning to learn

Terrapin was not just given the ability to adapt; it was trained to be good at adapting. Part of its training specifically teaches it to pick up a new kind of problem from just a few examples. So its capacity to learn is itself something it got better at, rather than a fixed skill set that stops growing when training ends.

This is the deepest version of the difference between Terrapin and a conventional model. A conventional model's learning is a phase that happens once, before it is deployed, and then stops. Terrapin's adaptation keeps working during use.

Why the learning stays trustworthy

A model that changes itself freely could just as easily get worse as better. It might pick up a habit that felt right but was not, and, because the change compounds, drift somewhere you did not intend and cannot easily trace.

Terrapin avoids this with a validation gate on what it keeps. A new lesson is held provisionally, checked against held-out problems, and kept only if it demonstrably improves performance. Lessons that do not help are discarded rather than compounded. This is what makes "improves over time" actually hold over time: Terrapin accumulates verified gains along a rising curve, rather than wandering on unverified self-modification.

The gate also means the learning is auditable and reversible. Because only validated changes are kept, and prior capability is protected, Terrapin can roll back if a problem is detected.

What it does not do

Terrapin does not rewrite its own capabilities without checks, and it does not autonomously invent entirely new strategies from nothing. It refines and optimizes within what it has learned works, and every refinement it keeps had to earn its place by improving results. Fully autonomous, ungated self-improvement is a different and much harder problem, one with real safety questions, and it is deliberately left to a future version rather than included here. See the roadmap for more on that boundary.

An example

Suppose you use Terrapin regularly for a particular kind of work. Within each session it adapts to the specifics of what you are doing. Across sessions, it consolidates the approaches that worked into its memory, so it gets more efficient at executing the way you like to work. And over many sessions, because it only keeps what measurably helped, it can surface refinements: an ordering that caught issues earlier, a step that turned out to be redundant. It compounds what genuinely works, checked at every step, rather than parroting your habits back or changing your approach on a hunch.

Capabilities

Terrapin is a general reasoning model. Its capabilities come from how it is trained and what its architecture makes possible.

What it is built to do

Reasoning. Terrapin is trained to think step by step and show its work, producing genuine chains of reasoning rather than pattern-matched answers. This is the foundation everything else builds on.

Learning. The defining capability. Terrapin adapts to new kinds of problems from a few examples, remembers what worked across sessions, and improves over time. This is what sets it apart from frozen models.

Prediction. By reasoning about how systems work rather than memorizing patterns, Terrapin can anticipate outcomes and failure modes, working forward from cause to effect.

Coding. Terrapin learns to code by solving real problems and building real projects, writing code, running it, and learning from whether it actually works, rather than only reading finished code. Its reasoning and step-by-step training make it a natural fit for programming tasks.

Explainability. Through its symbolic reasoning layer, Terrapin can produce an inspectable derivation, a real chain of steps you can follow and check. For anyone who needs to trust or verify a result rather than just accept it, this is a meaningful difference.

What using it feels like

Terrapin's advantages show up over a relationship, not in a single question.

A conventional model is the same stranger every time you open it. On a one-off question it will feel like a competent reasoning model, and that is genuinely what it is. But the thing that makes Terrapin different is cumulative. Over repeated use it starts to feel like it has gotten better at helping you: it stops repeating past mistakes, anticipates how you like things done, and sharpens on the kinds of problems you actually bring it. That accumulation is something a frozen model structurally cannot offer.

Honest about the bar

Terrapin is not built to beat the largest, most expensive models on raw one-shot capability on day one. On sheer horsepower it aims to approach the frontier. Its edge is a different axis: learning, adaptation, and continual improvement, the things no model you can actually own and run does well today.

Put plainly: match or approach the frontier on reasoning and coding, and decisively lead on adaptation and continual learning.

Breadth over specialization

Terrapin is trained for reasoning first and for breadth across many fields, science, mathematics, and others, at balanced weight, rather than being specialized into a single domain. This is deliberate: reasoning generalizes across fields, and a model that reasons well can bring that capability to almost any subject. The goal is a strong general reasoner, not a narrow expert.

Honest Roadmap

Terrapin is genuinely ambitious, and part of building in the open is being honest about what is proven, what is still being proven, and what is deliberately left for later.

The guiding rule

Nothing scales to the full model until it proves itself on a small one.

Every part of Terrapin is validated on a small model first, cheaply and quickly, before it is built at full scale. A component that does not work at small scale is fixed or set aside before it costs serious time or compute. This turns an ambitious design into a sequence of contained, checkable steps.

What is well-established

The foundation of Terrapin rests on proven ground. Training a model to reason step by step, and then sharpening that reasoning by rewarding sound thinking, are well-understood techniques behind today's strongest reasoning models. Starting from a strong open model and training it into a new identity is common practice.

This matters because it means Terrapin has a reliable floor. Even in the ambitious parts of the design run into difficulty, a capable reasoning model still results. The novel components are upside, not a single point of failure.

What is ambitious

The parts that make Terrapin distinctive, native plasticity, the neuromodulator, the symbolic reasoning layer, and adaptive expert routing, are drawn from real research but have mostly been demonstrated at smaller scale. Bringing them together in one model at a meaningful scale is genuine frontier work, and some of it may need many iterations or may not work the first way it is tried.

This is stated plainly on purpose. The honest position is that these are real bets with real uncertainty, contained by the reliable floor beneath them and proven on small models before they are scaled.

What is deliberately deferred

Terrapin learns continually and improves over time, but always through a validation gate that keeps only what demonstrably helps. There is a more extreme version of self-improvement, a model that freely rewrites its own capabilities with no validation. That version has the least understood safety profile in the field, and it is intentionally not part of this model. It is left to a possible future version with a dedicated, safety-focused design of its own.

This is a deliberate choice, not a limitation. Building the validated, stable version first is what earns the right to attempt the harder version later, carefully.

Built in the open

Progress is documented publicly, including the setbacks. Training runs fail, plans change, and hard problems stay hard for a while. Building in the open means showing that honestly, rather than presenting only the finished, polished result. If you want to follow or support the work, that openness is the point.

FAQ

What is Terrapin, in one sentence?

An open large reasoning model that keeps learning after training, adapting as it thinks and remembering what worked across sessions, instead of staying frozen like most models.

How is this different from other AI models?

Most models are fixed once training ends. They cannot learn from your use or get better at your problems. Terrapin's connections adapt while it reasons, and a memory carries validated lessons across sessions, so it improves over time. Its edge is learning and adaptation, not raw size.

How is this different from reinforcement learning?

Terrapin uses reinforcement learning, as part of its training, to sharpen the quality of its reasoning. But reinforcement learning happens during training and then stops; the model it produces is frozen afterward. Terrapin's plasticity and memory keep working after training, during use. Reinforcement learning shaped the starting point; the ongoing, in-the-moment adaptation is the part that keeps going.

Does it really learn my methodology, or just remember facts?

It can genuinely learn how you work. As you use it, its memory consolidates the approaches that succeeded and the way you like things done, so it gets more efficient at working your way over time. Because it only keeps changes that are validated as helpful, it can also surface refinements that measurably improved results, rather than simply repeating your habits.

Will it change its own behavior in ways I do not want?

No. Every lasting change passes a validation gate: it is kept only if it demonstrably improves results, and it is auditable and reversible. Terrapin does not rewrite itself freely. The fully autonomous, ungated version of self-improvement is deliberately left out of this model.

Is Terrapin better than the big frontier models?

On raw one-shot capability, it aims to approach the frontier, not beat it on day one; those are billion-dollar training efforts. Where Terrapin leads is adaptation and continual learning, the ability to keep improving from use, which no model you can currently run yourself does well. The honest claim is: match or approach on reasoning and coding, lead decisively on learning.

What is it built on?

Terrapin is initialized from a powerful open model and then trained into its own architecture and identity. Starting from a strong open foundation is what makes an independent, capable model possible on an independent budget. Its distinctive components are native to its design, and heavy retraining moves it into its own identity.

Can I run it myself?

Terrapin is being built as an open model, intended to be run on your own hardware and released for people to use and inspect. It is a work in progress; follow the project for release details as they come.

Is it finished?

No. Terrapin is an active, build-in-public project with an honest roadmap. Some parts are well-established, some are ambitious and still being proven, and progress, including the setbacks, is documented openly.

Who is it for?

Anyone can use it as a general reasoning model. It especially appeals to people curious about how a model actually works, its brain-inspired design, its inspectable reasoning, and the idea of a model that keeps learning.

How can I support it?

Terrapin is an independent project supported by people who believe in open, learning-first AI. If you would like to help it grow, follow the project and consider sponsoring the ongoing work.