Plastic Labs Internal Wiki

Recently Updated

propositional-analysis

15 min read

Why Honcho Breaks Everything Down First

The one-sentence version: Before Honcho reasons about a person, it rewrites everything it learns into small, standardized statements — because you can run logic on statements, and you can’t run logic on a paragraph.

What Honcho is trying to do

Honcho’s goal is to learn everything that can reliably be known about a person (or any peer — an agent, a brand, a codebase), with full nuance, and to keep learning as new information arrives. The ambition is a better model of the user than the user has of themselves.

That level of understanding is what’s coming due. Agents are taking on longer tasks with less supervision, and their appetite for context only grows. An agent acting on your behalf needs to act as you would — which requires a high-fidelity representation of who you are, not a pile of chat logs. That representation is also the steering wheel: it’s how a person aligns and directs agents without re-explaining themselves every session. And it’s what customers increasingly demand in practice — memory they can trust, where every belief can be traced back to its source.

Everything below is about the first step that makes this possible.

Why messages aren’t enough

Honcho keeps every message. Messages are the ground truth — the permanent record of what was actually said, and the thing every derived belief must trace back to.

But a message is a record, not a usable unit of knowledge. The information in it is locked inside phrasing: compound sentences, hedges, pronouns, sarcasm, things implied rather than stated. If messages are all you have, then answering any question means re-reading and re-interpreting raw text every time — and combining a claim from Tuesday with a claim from March means hoping both surface together and get read correctly, every time. Retrieval-based memory systems fetch text that looks similar to the question. What you actually want is what follows from everything the person has said. Similarity can’t give you that. Reasoning can — but not over raw transcripts.

The method: formal logic, in plain language

There are two obvious ways to have a model learn about someone, and both fail.

You can hand the model a taxonomy — learn their job, their hobbies, their relationships. But now the model only learns what the taxonomy names. Everything outside it is missed, and the taxonomy itself becomes a thing you maintain forever, always one category short of what mattered.

Or you can go fully open-ended — “read this and come to some conclusions.” But then you’re just hoping the model discovers what’s important. There are no rules to set, nothing to evaluate against, no way to gauge certainty, and no training signal to improve on.

Honcho sits deliberately in the middle: formal logic, used as a natural-language framework. Logic, in the sense meant here, is the discipline of correct inference — a system of rules for determining what else must be true, is probably true, or is plausibly true, given a set of statements. Formal means the rules operate on the structure of statements, not their subject matter: “all A are B; x is an A; so x is a B” holds whether it’s about jobs or dogs, which is what makes an inference checkable without re-litigating its content. Put practically: logic is the formal method for figuring out what information is entailed in any other information — what follows from what. Its rules are well-defined, and they are deeply represented in what language models already learned in pretraining. That combination is the whole trick: the space of exploration stays open (logic doesn’t dictate what to find, only how to find it soundly), while the rules give us something to evaluate against, train against, and trust — if there are reliable conclusions to reason toward, they get reached, and each one carries its own level of certainty.

But logic has an entry requirement: it operates on clean premises, not paragraphs. Preparing those premises is the explicit step, and the method is propositional analysis.

What propositional analysis is

Every message that enters Honcho gets decomposed into propositions — statements that are each simply true or false, relative to the message they came from, one claim per statement.

Take one sentence, from a message Alice sent on July 2, 2026: “I’ve been stressed about the product launch but excited about the investor meeting next week.” Propositional analysis turns it into six separate statements:

  • Alice is experiencing stress
  • Alice has an upcoming product launch
  • Alice’s stress is related to a product launch
  • Alice has an investor meeting
  • Alice’s investor meeting is during the week of July 6, 20261
  • Alice feels excitement about the investor meeting

One messy sentence became six clean statements, each usable on its own. Nothing was lost, and nothing was invented.

Two terms make the rest of this legible. A premise is a statement you reason from; a conclusion is a statement you reason to. Inside Honcho, these propositions are themselves called conclusions — because they’re the output of the first act of reasoning: working out what a message actually asserts. Every later reasoning step produces more conclusions, and any conclusion can serve as a premise for the next step. One uniform building block, all the way up the tree.

What makes a proposition good

We call them molecular propositions because they balance two forces:

  • Small enough — one claim, no “and”s. This isn’t stylistic; it’s how models work. A model reasoning with a premise takes the whole statement into its context — a bundled statement drags irrelevant claims into every argument that touches it. If one half is true and the other false, the statement has no single truth value, and any chain built on it inherits that confusion. And in search, a two-claim statement sits between two meanings, matching neither well.
  • Complete enough to stand alone — “Bob said hi” is worthless without knowing who Bob is or when it happened. Each proposition carries its own context, so it stays meaningful wherever reasoning later picks it up.

Three more properties matter:

  • Faithful. “I might get a dog” never becomes “Alice will get a dog.” Hedges, tense, and who-said-what are preserved exactly. A distorted premise produces confidently wrong conclusions downstream.
  • Exhaustive. Capture everything, not just the interesting parts. More on why below.
  • In plain language. No symbols, no code, no rigid schemas. Language models reason best in language, and natural language never runs out of room for nuance.

All of this runs in production at ingestion today, and all of these properties are or should be benchmarked — atomicity, coverage, fidelity, redundancy each get scored. That’s the point of choosing logic as the framework: quality here is measurable, not vibes.

The reasoning this prepares for

With a base of clean propositions, three kinds of reasoning run over them. Each has different rules, reaches a different kind of latent information, and carries a different level of certainty — qualified in plain language, not hidden in an arbitrary score.

  • Deduction — conclusions that necessarily follow. The rule: if the premises are true, the conclusion cannot be false. A stated birthday plus today’s date yields an age nobody ever typed. Deduction extends knowledge to everything the evidence guarantees.2
  • Induction — patterns generalized from repeated instances. The rule: the more instances, and the more representative they are, the stronger the conclusion — probable, never certain. She’s mentioned Sunday runs eleven times; she runs on Sundays. Most of what matters about a person is a pattern that was never stated once, and induction is the only way to get it.
  • Abduction — the best explanation for the evidence. The rule: prefer the hypothesis that explains the most with the least, judged by explanatory power, simplicity, and coherence — then hold it as a hypothesis and test it against new evidence, keeping it only if it survives. This is how the deepest material gets reached: motivations, goals, the why behind the patterns — things nobody ever states and no pattern-count can prove.3

Together the three cover the full space of what can reliably be reasoned toward: the certain, the probable, and the plausible-but-testable — each labeled as what it is. And all three consume the same input. That’s why normalization is the critical move: every proposition, however and whenever it arrived, is a premise any of these processes can pick up and combine with any other.4

This is intended behavior — and failure compounds

Everything above describes both what the system does (or should be doing) and what it is held to. The distinction matters. Conclusions are load-bearing: every later belief is built from them. When the explicit step fails — a hedge dropped, a friend’s job attributed to the user, an agent’s words recorded as the human’s — the error doesn’t stay put. It becomes a premise, and deduction faithfully propagates it, each hop more specific and more confident than the last. A mangled statement isn’t one wrong entry in a list; it’s a crack in a foundation with a building on top.

So if any of this is not working as intended, that is a real problem — not a quality nice-to-have. It’s why this step is benchmarked directly, and why defects here get treated as defects, not variance.

Why “trivial” statements still matter

Many propositions look like pointless restatements — of course she has a product launch; she just said so. But “trivial” is a judgment you can only make against today’s questions. Next month’s deduction may need exactly that statement as a premise, and meta-reasoning over the whole representation needs the unremarkable statements as much as the striking ones. The promise is: if the context was available, Honcho has it. Trivial capture is what makes that promise true.

And you can’t just leave the trivial ones in the messages and go find them when needed. A claim locked inside a message only exists once something re-reads and re-interprets that message — correctly, with full surrounding context, every single time. Search doesn’t do that: it retrieves text that looks similar to a query, not claims that were asserted. A statement can only serve as a premise once it is a statement; extraction is what moves it from findable-maybe to usable-now.

Why we remember maximally

Honcho shouldn’t delete what it learns — it re-reasons. When something turns out to be wrong, outdated, or sarcasm we missed, the correction is added as new evidence and reasoning runs again; the old conclusion is outweighed, not erased. That’s deliberate: knowing that something was true and no longer is is itself information. So is knowing we got something wrong. You can scaffold further reasoning on top of a correction; you can’t scaffold anything on a deletion and you have to delete everything that relied on the deletion. The result is a full trace of how understanding evolved — which is also what makes the system auditable: any belief traces down to the first time the user actually said the thing. That’s the design we should hold ourselves to; where the system falls short of it today, that’s treated as distance still to close, not a different philosophy.

Duplicates are signal — with one open question

When the same statement gets derived again from a separate message, that’s not clutter — it’s independent confirmation. The person said it again, unprompted, on a different day: confidence should rise. (Duplicates from within a single message are just noise, and should get treated as such or ideally not ever occur at all.)

Whether storing another copy is the right mechanism is an open question. The better move may be to reinforce the existing conclusion — increment it, weight it more heavily in later reasoning — rather than accumulate duplicates. The principle underneath is settled either way: repeated derivation from independent sources is evidence, and the system should get more confident because of it.

The bottom line

The explicit step looks mundane — it just restates what people said. That’s exactly why it’s critical. It’s the step that converts a record of conversation into premises that logic can run on, and everything Honcho ever concludes about a person — every deduction, every pattern, every tested hypothesis — stands on these statements. They are only as good as this step makes them.

Appendix: where the implementation is today (July 2026)

The body of this document describes the design. Here is the honest delta against the shipping v3 code — for engineers who will read the source next, so nothing above reads as overclaiming. None of this changes the design; it’s the distance-to-close list.

The explicit step runs lean. The production ingestion prompt is deliberately minimal — its own docstring says “optimized for speed… just extract observations.” It carries the core of propositional analysis (self-contained conclusions, sufficient contextualization, correct attribution, absolute dates), but the full molecular criteria — exhaustive extraction of presuppositions and entailments, systematic compound-splitting, the naming rules — live in the richer design prompts and are enforced today mainly through benchmarking after the fact, not in the ingestion prompt itself.

Temporal grounding is instructed, not enforced. Every message reaches the deriver stamped with its timestamp, and the prompt instructs absolute dates “when possible.” Nothing validates that resolution happened; a relative reference can still slip through into a stored conclusion.

The explicit/deductive boundary blurs in practice. The production prompt’s own examples fold a one-hop deduction into the explicit step (“alice attended college” plus general knowledge yields “alice completed high school or equivalent”). Cheap and useful — but it means “explicit” as stored is not purely what-the-message-asserts.

Deduction and induction run asleep, not at ingestion. The design calls for deriving reachable conclusions as data arrives plus continuous background reasoning. Today, ingestion writes explicit conclusions only; deduction and induction run in a background process that wakes after roughly fifty new explicit conclusions have accumulated, at least eight hours since its last run, and an hour of quiet. Deductive conclusions must cite their source statements; inductive patterns require at least two independent sources and carry confidence tiers. Practical consequence: a young representation is explicit-only until the background reasoning has fired.

Abduction is not implemented. The background reasoner has exactly two specialists — deduction and induction. There is no hypothesis-formation-and-falsification loop in the code today. This is the missing third leg of the design, not an optional extension.

Deletion still happens. The deprecate-not-delete stance is partially realized: the background deduction process currently has a hard delete tool and prunes stale conclusions when it records a knowledge update. The target — supersede and outweigh, with the full history of understanding preserved — is design intent the code hasn’t fully caught up to.

Duplicates are suppressed imperfectly, and not yet reinforced. A deduplication guard exists but near-duplicates still accumulate across sessions. Counting repeated independent derivation as a confidence signal — the reinforcement model the body of this document argues for — is not built.

Perspective is stored, not reasoned. Conclusions carry observer/observed scoping in the data model, but a single extraction pass currently stamps identical text into every direction; nothing yet phrases or reasons from a specific observer’s point of view.

Each of these is tracked internally. The pattern across all eight is the same: the formal-logic framework is the settled part; the distance is in how exhaustively and how strictly the implementation lives up to it.

Footnotes

  1. This bullet is where engineers should look closest. “Next week” is only true relative to when the message was sent — as a stored statement its truth value drifts with the calendar, which disqualifies it as a stable premise. So relative references get resolved at derivation time: every message reaches the deriver stamped with its timestamp (2026-07-02 14:32:07 alice: ...), and the extraction prompt instructs absolute dates (“June 26, 2025,” not “yesterday”). The same principle extends past time to every context-dependent expression — “here,” “my boss,” “the launch” — sufficient contextualization means resolving each into a reference that holds anywhere. In full rigor the stative statements carry an anchor too (“as of July 2, 2026, Alice is experiencing stress”); the bullets above are kept clean for readability. Today this grounding is instructed rather than enforced — see the appendix. ↩

  2. Deductions can also be probabilistic. Validity guarantees the conclusion only if the premises are true — and a premise is often itself merely probable (an inductive pattern, a hedged statement). A perfectly valid deduction from a probable premise yields a probable conclusion: logical form transfers the premises’ confidence, it doesn’t mint certainty. Some deductively-shaped arguments are also inherently statistical (“most people who mention a commute have a job; Alice mentions a commute”). Either way, the conclusion is labeled with the confidence of the weakest premise it stands on — in plain language, not a hidden score. ↩

  3. Honest status as of July 2026: abduction is not running. Deduction and induction are in production; abductive hypothesis formation and falsification is designed but not implemented. It’s the missing third leg, and building it is a need, not a nice-to-have — the deepest layer of the representation depends on it. See the appendix. ↩

  4. With one guardrail: probable conclusions don’t get scaffolded on probable conclusions. Uncertainty compounds multiplicatively — chain two 80%-confident statements and the result is ~64%; five links and you’re near a coin flip, while the final statement still reads confident. So inductive and abductive conclusions must be supported by premises that trace back to explicit or deductive ground, and reasoning doesn’t stack new probable conclusions on unresolved ones without re-grounding in that evidence base. Chained speculation is exactly how a small early error grows into a confident fiction — we have watched it happen in our own deployments — and this rule is the fence against it. ↩

Graph View

Backlinks