Skip to content
Chad Brown
Chad Brown
  • Most of What an Agent Sees, It Admitted Itself

    Every discussion of context as a scarce resource eventually arrives at what to do about the material already in the window: what to trim, what to summarize, what to replace with a reference. That is the downstream half of the problem. The upstream half is deciding what was allowed in to begin with, and it is the half that determines how…

    Read More Most of What an Agent Sees, It Admitted ItselfContinue

  • Conversation History Is State You Own, Not a Transcript You Append To

    A transcript is a record of what happened. The conversation history you hand a model is not a record. It is the evidence the model reasons from when it decides what to do next, and those are different artifacts with different requirements. Collapsing them into one object produces a specific, under-diagnosed class of failure: systems in which the accumulated past quietly…

    Read More Conversation History Is State You Own, Not a Transcript You Append ToContinue

  • Memory That Outlives a Session Is a Different System, Not a Longer One

    Inside a single engagement, memory is nearly free. Everything said, decided, and returned is already sitting in the context the model reads, carried forward by a default append that costs no one any thought. Retention is the cheap default and forgetting is the thing that costs you, which is why the entire discipline of managing a long conversation is about what you…

    Read More Memory That Outlives a Session Is a Different System, Not a Longer OneContinue

  • A Long Conversation Can Fit in the Window and Still Lose the Thread

    A conversation that runs long fails in two different ways, and they are easy to confuse because both show up as the model getting worse over time. The first failure is mechanical and visible: the accumulated history grows until it no longer fits in the window that holds it, and something has to give. The second is quieter and, in most…

    Read More A Long Conversation Can Fit in the Window and Still Lose the ThreadContinue

  • An Unpruned Scratchpad Eventually Does More Harm Than Good

    Writing a scratchpad is the easy part. A store that carries an agent’s state across sessions, whether that is a file in a coding agent’s workspace or a record in the datastore behind a deployed system, can be stood up in an afternoon, and on day one it does exactly what it promises. The difficulty is not authorship. It is keeping…

    Read More An Unpruned Scratchpad Eventually Does More Harm Than GoodContinue

  • The Scratchpad Is the Memory the Runtime Refuses to Keep

    An agent has no memory of its own work. Each session opens with a blank context window, and everything the previous session learned, the approaches it tried and abandoned, the naming it settled on, the reasons behind the choices already made, is gone the moment that session ends. This is not a defect to be patched. It is the shape of how these…

    Read More The Scratchpad Is the Memory the Runtime Refuses to KeepContinue

  • Trimming a Tool’s Output Is Three Decisions, Not One

    Once you accept that a tool’s raw output should not enter context unchanged, the reflex is to treat trimming as a single technique with one implementation: strip the payload down to what the agent needs and pass along the remainder. That framing hides the actual decision. There is no single trim. There are three distinct strategies, they trade away different resources…

    Read More Trimming a Tool’s Output Is Three Decisions, Not OneContinue

  • Every Field a Tool Returns Is a Cost the Model Keeps Paying

    The most-watched numbers in an agent system are usually the prompt and the model’s own output. The instructions get versioned, the responses get graded, the system prompt gets audited line by line. Meanwhile the largest and least-examined source of tokens in a long-running agent is often the raw output of the tools it calls. A single API response can be…

    Read More Every Field a Tool Returns Is a Cost the Model Keeps PayingContinue

  • The Persistent Fact Store Is a Subsystem, Not a Feature

    Once you accept that a summarizer will drop the exact values a long session depends on, the fix is easy to describe and easy to half-build. Pull the facts out of each turn before compression runs, write them into a durable region the summarizer never touches, and the values survive while the narrative is free to shrink. Stated that way, a…

    Read More The Persistent Fact Store Is a Subsystem, Not a FeatureContinue

  • Summarization Preserves the Story and Silently Drops the Facts

    Long conversations outgrow the window that holds them. A session that runs for hours, an agent that works a task across dozens of turns, a support thread that keeps accumulating, all of them eventually carry more history than the model can take in at once. The standard answer is to compress the older part of that history into a shorter…

    Read More Summarization Preserves the Story and Silently Drops the FactsContinue

Page navigation

1 2 Next PageNext
  • LinkedIn