ideal reasoned representations

Courtland’s memo, December 10, 2025—the design north star for the reasoning system: memory as generative simulation, formal logic as the framework, waking and dreaming cadences, and the Platonic representation. Published to the wiki unchanged, July 10, 2026. Its sufficient-contextualization thread is developed further in Sufficient Contextualization.

This doc is a first attempt at formalizing what an ideal system for Memory as Reasoning might look like.

NOTE: Short-term, we’re focused on maximizing pareto dominance doing whatever works so we can—

1. Broadcast this for growth
2. Understand what the ideal needs to outperform
3. Buy time to work on what follows

So what follows is a description of the medium-term (I’ll get into longterm ambitions a bit at the end) which should not slow down the short-term. We push forward on what’s working, building toward this in tandem.

North Star

The whole idea behind this approach is to capture all latent information from messages.

That means a representation should contain everything it’s possible to know about a peer at any given time.

It’s not our job to decide what context might be important to a developer or agent. Our job is to make sure that if it’s possible to have the context they need, we have it.

A Taxonomy, Memory, & CogSci Primer

Memory feels subjectively like storage and retrieval and that’s how our tech tools have traditionally approached it as well. And that’s what most people mean when they say “memory.”

But I don’t think “memory” defined this way actually exists.

Really what leading contemporary cognitive science tells us memory is, is a simulation of the past.

Humans encode representations of sense data/experience, then use that to reconstruct a simulation later. Instead of storing and retrieving the past, we predict what the past was like. It’s generative.

But now we have LLMs and they’re simulators(!), so we can build systems that act like memory actually operates and it promises to work better. A generative, AI-native approach.

So the question becomes, if we’re approaching a synthetic system of memory from first principles, how do we use this new affordance to maximize the robustness of a representation?

Most approaches try to mimic human memory taxonomies that are at worst incorrect and at best limit the personal identity modeling they can do¹.

1. Episodic, Semantic, Associative, etc distinctions are useful ways to define types of human memory so we can talk about categories, but critically they don’t describe how those memories are actually formed. This leads to a category error on the part of memory solutions, as they use them as instruction for memory formation, which limits the scope of memories they can produce. That equals missed context.
2. Long-term, Short-term, etc distinctions are the same as above. They map well to talking about say a context window vs storage, but are not meaningfully different in a way that would impact architecting a synthetic system.

The real answer is we dispense with distracting taxonomies and get down to the now accessible base processes. We need to build the best representations from data coming in, so we can run the best simulations on top of them (i.e. simulating state in an agent).

That means a system for capturing all the latent context available.

Formal logical reasoning is designed for this exact use case.

A Brief History of Formal Logic

Formal logic basically exists because if left to its own devices, the human brain misses a lot of information.

Brains evolved under resource constraints, so they had to come up with lots of tricks (like prediction & surprisal) to build useful internal world models. That means they only process the bare minimum of information to keep the world model current enough to stay alive and reproduce.

But humans realized that if we want world models that are accurate enough to understand and manipulate reality better, we needed to hijack these evolved systems and force them to do better.

So we developed some rules for consistent and reliable thinking. Thinking that’s more objective and repeatable. Thinking that scales.

The rules allow anyone with training to pick up the thread of someone else’s careful thinking and build on it. Mathematics and engineering, then science, then computer science all evolved as derivatives of formal logic.

The key innovation is that logic allows you to understand what information entails, beyond just the information itself. At its base, it’s prediction—if some set of information is true, then what follows? It’s simulation.

You run these logical simulations to squeeze all the information you can out of any set of data available².

The last part of the history lesson is humans proceeded to do a raging shit-ton of logic and wrote a lot of it down³. Then we compressed that whole corpus into our LLMs.

Interlude

OK. So we need to build a continual learning system that constructs representations we can use to optimally simulate state in agents.

The goal is to capture all latent information, so that if the context is available, Honcho has it.

Formal logic is looking like a pretty good candidate for this. It’s rule based and evaluate-able, it scales, it’s a well represented task in pre-training, and reasoning models are a thing and they’re fucking good. Models do this well and more reliably than humans. They’ve read all the logic we’ve ever written down, they’re fast, do what they’re told, and they don’t get tired and refuse or start making mistakes. Logic is a simulation and models are simulation slaves.

They can do the logic, they can judge the logic, they can be trained on more logic.

Since I decided to go ham here, let’s just finish the job and lay out the tools we have at our disposal, then we can get to how we’ve been imagining we actually architect Honcho to take full advantage.

Logic 101

Formal logic is a rich field of inquiry, it goes as deep as anything else, but since right now we’re working with natural language, we only need the basics and we can operate at the highest level.

To be honest, I expect we’ll crack per-peer models and true continual learning operating at the level of model weights well before we need to go deeper here.

Formal logic is all about premises and conclusions:

• Premise - An atomic statement with one truth value

• Conclusion - An atomic statement entailed by n premises

Premises are atomic in order to keep things rigorous. If you have a compound statements then you sacrifice modularity and composability. Basically, you can’t scaffold premises to reach conclusions dynamically and fluidly enough because you can only use them if both parts of the statement are relevant⁴.

And conclusions can be used as premises to reach further conclusions.

There are lots of ways that premises can entail conclusions, and again, the we only need the basic, high level categories since we’re working with intelligent systems and natural language—no need to go symbolic or more granular⁵.

• Deductive - What conclusion is necessarily true if the premises are true?

• Inductive - What general conclusion is probable if specific premises are true?

• Abductive - What parsimonious conclusion best explains a set of true premises?

I’ll leave it there. For a much more comprehensive sense of the rules around each of these, check out these prompts in Linear. They’re not the best, but they’re an attempt a breaking out each reasoning type into one task. Or just ask a model.

Also there’s an “explicit” prompt. That one is meant to convert messages into all possible atomic premises that we can then use to do the three reasoning types. It’s pre-logic work.

Current Representation Context

Right now in Honcho, explicit and deductive tasks are done at the same time for every message. The conclusions we produce are what form the representation.

We batched them this way because both of these tasks are reasoning toward certainty—explicit conclusions are what’s literally in the message and deductive conclusions are what we can be certain about given the explicit.

The thinking was isolate this certainty task, then do a “predictive” task (induction & abduction) that produced probabilistic conclusion separately afterward.

Despite eval success there are a few problems with this approach:

• You’re asking for two fundamentally different tasks in one shot, this makes latency and model selection and datasets and evaluation and judging and training messy
• The deductions produced are super obvious and only scoped to a single message, you could probably get them with better explicit reasoning alone
• It shouldn’t even be necessary, if the goal of the explicit task is to expand messages into all possible atomic conclusions, then that by itself should be enough to ace evals against competitors who take more opinionated approaches on what context is worth keeping/creating
• We need more prompting space to define each of these tasks better

So a few months ago we concluded that it would be best to isolate each task in Honcho and train specifically for each (can always create a mixture model later too).

That means that the only roughly “synchronous” task is explicit reasoning. That is, converting and expanding every message into all possible atomic statements that can be used as premises to reach further conclusions later.

Then, deduction/induction/abduction can be done later, asynchronously, each a “dreaming” task done over the representation.

Platonic Logic Representations

OK. So what’s the ideal, mature version of this approach? Here’s how we’ve been thinking about it.

Representations are simulations of a peer, i.e. they are the entire body of reasoning we’ve done about each peer.

And that reasoning should form a vast tree, with messages at root, explicit then deductive conclusions above that, and predictive conclusions (inductive/abductive) at the edges. So any conclusion we surface about a user as context for an agent should be supported and qualified by the entire tree of reasoning behind it. And ideally this tree is traversable for retrieval, maintenance, and new reasoning.

We can think about this reasoning happening at two cadences: “waking” and “dreaming."⁶

"Waking” Reasoning

This just means synchronous or more or less live. Basically messages come in, they’re batched, and we reason about them so that reasoning is available at very low latency.

The reasoning we do here is just explicit reasoning⁷.

Explicit Reasoning

Theoretically, we should be able to define this task well enough that this alone crushes evals. That’s because we’re creating conclusions to painstakingly cover everything in a message that contains a single proposition with a single truth value.

This creates our arsenal of premises we can bring to bear to do later reasoning.

One notable thing that differentiates this task from the other reasoning types is that we actually have a kind of ground truth—we have the original message.

In the past, we’ve face two major failure modes with explicit conclusions:

1. They aren’t sufficiently contextualized. E.g. “Alice is excited”…about what?!
2. They aren’t atomic enough. E.g. “Alice has a dog and she likes walking it”…this is two statements, so it should be two separate conclusions, not one.

But we’ve found that these are very tractable with prompting alone.

In order to evaluate a system for explicit conclusions, a human or LLM judge should assess the following:

1. Is the conclusion sufficiently contextualized?
2. Is the conclusions sufficiently atomic?
3. Is the conclusion semantically contained in the message?
4. Do the set of conclusions produced cover the entire semantic context of the message?
5. Check out my exhaustive prompt for more.

The most efficient methodology will be a hybrid human-LLM system to train a judge with as thin a margin for error as we can achieve.

”Dreaming” Reasoning

Dreaming just means we do the reasoning asynchronously at some cadence. Each dreaming task can have a different scheme and figuring that out is a pretty significant challenge.

Basically, we take the reasoning that’s already in a peer’s representation and use it to reason more. This is where we’ve been imagining we do deduction, induction, and abduction.

There may also be other types of dreaming tasks. E.g. consolidation is one—collapsing redundant conclusions into single conclusions, linking separate trees if necessary, and updating metadata with a tally of how many times this conclusion has been reached. We’ve also discussed exposing dreaming to the developer/agent, so that they can queue dreaming tasks specific to their application (perhaps to search for opportunities to do reasoning about a certain topic).

Deductive Reasoning

Deductive conclusions are those which we can be certain about given a single or set of premises. Part of the nature of certainty, is that many of these will be obvious and unexciting. The space of things to be certain about is just a much smaller space than the space of things we can have probabilities about.

But this step is still critical because it allows us to tease out the obvious in a rigorous and well defined way, instead of just telling a model to figure out what’s “implied.”

We can only do deduction using explicit conclusions or previous deductive conclusions as premises because those are the only ones we can reliably count on to be “true” relative to the message they were concluded from. And premises must be true in order to do valid deductions⁸.

In an ideal scenario, we would seek to do deduction over every possible set of explicit conclusions and deductive conclusions contained in a representation. This isn’t currently realistic, so part of the challenge for this reasoning task is figuring out the appropriate sampling and cadence that gives us the meat of the benefit, but stops short of diminishing returns.

Important to note:

1. Deductions over conclusions from a single message are valuable because they rigorously articulate the implied and obvious but not explicit.
2. Deductions over conclusions from diverse and separate messages are also valuable as they discover conclusions we aren’t able to uncover in more locally scoped reasoning.

So this is an open problem. Traversable representations, agentic dreaming, and a dreaming queue produced from multiple sources seem pretty key to figuring this out fully.

However, that should not stop us from getting something in production. We can start simple, perhaps deducing over the explicit conclusions of a batch of messages triggered right after that process completes.

But do note that this does create the problem of isolated trees of reasoning based on batches of messages that must to be addressed eventually.

How do we evaluate deduction? We need to determine if a deduction is “valid.” Assuming the truth of the premises, validity means there is no possible situation where the conclusion could be false.

Some criteria:

1. Is there any situation where the premises are true, but the conclusion could be false?
2. Do the premises logically entail the conclusion?
3. Does the deduction contain probabilistic deductive conclusions as premises?
4. Are premises limited to explicit and deductive conclusions⁹?
5. Does the deduction produce a conclusions with a meaningfully different claim from those made in the premises?
6. See my exhaustive prompt for more.

Unless we give the model a scratchpad for truth tables and Venn diagrams, this is probably the best we can do and sufficient.

As with explicit, a hybrid judge system to train an autonomous judge seems the best path.

Inductive Reasoning

Inductive reasoning can be done over explicit and deductive conclusions¹⁰. It seeks to establish general conclusions from specific premises.

Much of what we’ve covered above can also be applied to inductive reasoning.

1. We need to determine the appropriate scheme
2. Ideally we do inductive over all possible sets of conclusions in the representation, but this probably isn’t realistic.
3. The above shouldn’t stop us from getting started, say by doing induction on batches after deduction completes.
4. But we’re still left with siloed tress that need to be brought into equilibrium in order to build the most effective system.

We can evaluate induction by seeking to establish “cogency.” That is, the premises are “true” (here meaning well supported by prior reasoning¹¹) and the conclusion is “strong,” i.e. probable.

Criteria:

1. How likely is the conclusion?
2. Is the conclusion a useful generalization from specific premises?
3. Are premises only explicit and deductive conclusions (+ general, temporal, metatdata knowledge, etc—see footnotes)
4. Are multiple premises present? Are they sufficient to establish a pattern?
5. See exhaustive prompt.

Abductive Reasoning

Abduction can be done over everything in a representation as it seeks the simplest, most useful explanation for a set of premises.

I won’t belabor the challenges, because they mirror the other types of dreaming reasoning above. We should make a plan to get started, if we attempt the linear approach described above, abduction should be last.

Eval criteria:

1. Parsimony
2. Explanatory power
3. Comprehensiveness
4. Plausibility
5. See more.

Worth noting here that induction and abduction can be thought of as denser nodes in these trees of reasoning. There should be more evidence behind them. That makes them good entry points for traversal, but is also good because predictive reasoning stands a greater chance of needing updates based on new information, i.e they’re more error prone.

Further Considerations

We know how to get a model to do these types of dreaming reasoning. We know why it’s valuable. And we know how to evaluate them.

We have open questions around when and how often and the technical methodology (e.g. how to sample conclusions for reasoning, how to sufficiently inter-reason over growing representations).

Also on my mind are a few features of dreaming for consideration:

1. Traversable Representations - As I understand it, representations aren’t actually connected in a tree of logic right now, but making this a reality has the potential to pay dividends for retrieval, transparency, maintenance, and…
2. Agentic Dreaming - an agent who can traverse representations and decide to call different dreaming tools to do more of a certain type of reasoning, execute on a queue, do maintenance, and…
3. Corrections, Contextualization, & Re-reasoning - We will learn things that in an ideal world would require we update a representation either because it’s a predictive conclusion that needs to be re-reasoned based on new information, or we straight up got something wrong¹²—traversable representations and agentic dreaming could make this tractable.

There are likely a lot more possible solutions and considerations. We should jam ASAP on fleshing all this out more rigorously and considering new ideas.

A Couple Training Notes

I also want to call out a couple training items that have been discussed recently for the medium-term. There are probably more that I’m not up on.

1. Judges, Meta-Judges, & Automated Training - We’ve been knocking on this door a bit already, but I think that training for all of these tasks can be progressively offloaded to the models themselves. The writing seems to be on the wall in ML. Our tasks are well represented, well defined, and many proven methodologies are emerging (SPCT, GRM, MetaRM, etc). We may have to bootstrap in places, but in many we may not and it’s important we get comfortable with this paradigm shift.
2. Extended Pretraining - We’ve talked about doing this for formal logic using textbooks, etc. Feels like there’s some promise there.

Long-Term Possibilities

Long-term (& it’s hard to predict the horizons here) we may find that we can supercharge this system or dispense with it entirely with new methodologies and new affordances becoming economical.

By this I mean true continual learning, per-user models, building peer representations at the level of model weights. Also, just letting models themselves figure out the best way to represent peers to remove all our prescription. I would love this to happen and work and render everything above irrelevant. If you know how to do this, do it, tell us. But absent that, for the reasons above and the time being, this seems to us to most promising path.

OK, I think that’s all I have. Realized in writing this how much context in my head I’m unsure the distribution of. So hopefully this is valuable. Let’s discuss.

🥽

Footnotes

1. Actually, they’re not really modeling identity, they’re just doing “memory.” That’s myopic because it’s not a thing and it’s not well applicable to AI. We can do memory better by approaching it as an identity modeling task. Further, identity modeling is a massive long-term project with far reaching implications and market opportunities. But LLM memory as the market has congealed around defining it does dovetail with our much more ambitious and important goal, so we can compete and win here, earning the right to keep pursuing the vision. ↩

2. It follows that arguments are simulations, reasoning is simulation, the derivatives (math, science, software, etc) are simulations. We basically took the prediction that humans do naturally to build world models and memory representations etc, formalized it, and used it to run simulations at scale to do more than a brain on the savannah would do left to its own devices. ↩

3. And we did logic in all its derivative forms, wrote treatises and textbooks on it, argued about it, dedicated chronicled lives to it, etc etc… ↩

4. Plus, if you’re dealing with LLMs, you have contaminating the space of generation to contend with, including irrelevant statements in the context window because they’re appendaged to relevant ones stands a good chance of impacting the space of generation in unpredictable ways, (it also wastes tokens) so again, best to go atomic. ↩

5. In fact, using symbolic logic would screw things up. Yes, maybe you could get more prescriptive, but you’d then have the added task of transforming every statement into symbols and operators. Then you’d have the problem of what the variables stand for and in even a small representation, it gets untenable basically immediately. We have machines that understand natural language, let’s take the W. ↩

6. I’m going to regret creating these terms, but I’m trying to map to the way we’ve been talking about it colloquially, let’s keep them internal for now. ↩

7. In some early prompting experiments I included “implicit” in this task as well. I think we can safely ditch this. It’s poorly defined and the reasoning we do in dreaming will take care of it. The thinking was that it could make up some of what might be lost by removing deductive from this stage, but ultimately it’s not necessary if we do explicit well. ↩

8. There’s a case to be made for this footnote to be in the main body, but I’ll do it here to keep things clean. One wrinkle worth noting is that deductions can be probabilistic as long as they follow the rules of deduction, but conclusions must include probabilistic qualifiers (likely, probably, etc). This is because we can conclude with certainty that something is likely, even if we can’t conclude that something is certainly true. E.g. “P: The Polymarket for a Fed 25 bps rate cut is at 75%, therefore C: the market thinks it is likely that the Fed will cut rates by 0.25%” is a valid deduction. However, we have noticed that reliability declines when you use probabilistic deductive conclusions as premises for further deduction, so have prohibited that in prompting. ↩

9. In my exhaustive deductive prompt I also allow premises from general knowledge, temporal data, and logical principles. We’ve found these affordances to be critical to covering a large enough surface area. ↩

10. Again, we should allow the model to use general, temporal, etc knowledge. See prompt for an exhaustive account. And again, I don’t think these are necessarily good prompts, but they define the tasks well. ↩

11. If we do our job with explicit and deductive, we can assume this. ↩

12. Very important to note here that there are important epistemic differences between (1) conclusions that were never true, (2) ones that were once true, and (3) ones that are true but need to be contextualized. Type (1) needs to be corrected and all scaffolded reasoning needs to be rerun. Type (2) is important to preserve, but we need learn that new information and potentially make updates across the representation. Type (3) need to trigger updates and relevant re-reasoning. I’m very much allergic to the term “forgetting” due to the nuance here. ↩