A language model wakes with no memory of you. It reasons only across the text you place before it — a desk, not a mind. What is not on the desk does not exist to the model.

Models are stateless the way a calculator is: each call takes an input, returns an output, and nothing survives. Everything called ‘memory’ is apparatus bolted on to smuggle yesterday back in.

Every response is a function of what sits in the window at inference. The model has not changed; your context did. Fill it with signal and it looks brilliant; fill it with sludge and it looks a fool.

Windows grew enormous, but the edge only moved. Models attend unevenly across long context — sharp at the start and end, hazy in the vast middle where you buried what mattered.

You can afford the tokens. What you cannot always afford is the model's finite attention. Most failures live in the high-volume, low-relevance quadrant — completeness mistaken for clarity.

A working system assembles a stack: instructions, retrieved knowledge, tools and memory, live state. The prompt is the thin top layer. A brilliant instruction on a bad stack yields a confident error.

Context is not a noun you hand over once. It is a loop: assemble, observe, revise. Teams shipping durable agents instrument what the model attends to and prune ruthlessly on the evidence.

The warmth is manufactured. Every answer lives in the overlap between a fixed training distribution and the context you supply. You can't move the training; the context is entirely yours.

Within a chat the model seems to remember. It doesn't — it re-reads the whole conversation from the top on every turn. As the document grows, early instructions sink toward the hazy middle.

Before adding anything, ask if it serves the task. That flinch of ‘it can't hurt’ is the single most reliable source of degraded output. Real caution is subtraction, not padding.

Persistence is not a self — it's a filing cabinet with opinions about what to keep. Memory is a loop of store, retrieve, evict. Everyone obsesses over the first two; eviction is what matters.

Working memory is hot, cheap, and short — the current thread. Long-term memory is slow, expensive, and enduring. Most bad agents fail at the seam, treating everything as one or the other.

Raw interactions don't age into wisdom on their own. Good systems compress like the brain in sleep — merging duplicates, resolving contradictions, promoting the recurring, decaying the one-off.

Vector search finds the similar; graph search finds the connected. The 2026 consensus is unromantic: use both. Each half covers the other's blind spot, and blind spots sink production systems.

Memory stopped being a place you write to and became a thing that edits itself — reading its notes, judging them, rewriting what proved wrong. The lineage runs back to ‘LLM as operating system.’

When a system remembers you, that memory lives on someone else's infrastructure — editable without your knowledge, retained past your leaving, consolidated to priorities not yours.

Run a store long enough and it holds two facts that can't both be true. Trust the recent for changed preferences; trust the frequent for facts about the world. Naive systems pick one rule blindly.

Retrieving the right fact is not the same as weighing it well. The industry poured effort into fetch-and-inject and neglected the hardest step — weighing the fact against everything else on the desk.

A system that remembers you is a genuine pleasure — and defaults become needs. Each thing it remembers so you needn't is a small competence outsourced, a slow transfer of your own continuity.

At any moment an agent holds a working set — this task, recent turns, live facts, the goal, the constraints. Curating that live selection is the discipline no framework can do for you.

Two temperaments: the hoarder dumps everything into the window; the librarian retrieves only what this question needs. The librarian's model arrives at a clean desk and it shows.

Embedding search finds what resembles your query. Resemblance and relevance are cousins, not twins. A document can score as a perfect match and contain nothing that answers the question.

Before retrieval a document is cut into pieces. Split by length and you guillotine sentences mid-thought; split by meaning and each chunk stands alone. The chunk is the atom of retrieval.

A retrieval system is only as current as its last indexing. Skip re-indexing and it develops a confident staleness — retrieving fluently, answering plausibly, describing a world that's gone.

For anything where current truth matters, fetch first and reason second. A model that reasons before retrieving reasons from its stale training and decorates the conclusion with whatever it fetched.

Every retrieval costs latency, money, and attention. In the demo these are invisible; in production they decide whether a system is used or abandoned. Fetch on demand, not by reflex.

When a model states something retrieved, the question is: from where? Without traceable provenance, a knowledge system is an articulate stranger. Models will invent plausible sources if unchecked.

The bravest thing a retrieval system can do is return nothing. Almost none do, because they rank by similarity and always return the top few — even when the top few are the closest of a bad lot.

The dream: a library that answers. Being close revealed its flaw — a library that surfaces anything will, unmanaged, surface too much. The funnel narrows from everything indexed to what served.

Retrieval well done is a quiet promise: fetch only what the question needs, cut at the meaning, keep the index fresh, carry the provenance, and refuse when nothing clears the bar.

Strip the branding: an agent thinks, acts, observes, thinks again. The beat everyone underweights is observe. An agent that acts without observing is a sleepwalker following a memorised route.

Tools let an agent reach into the world, but they don't make it decide well. Poor judgement with excellent tools is more dangerous — it executes bad decisions with reach and speed.

Humans commit to routes before walking them. We built machines that inherit the flaw and run it faster. A committer draws the whole map when it knows least, then follows it off a cliff.

An agent will fail — it's arithmetic. Bound the work into small recoverable steps so any misstep costs little. An unbounded run converts a small error into a large disaster while you're away.

Two agents on the identical model can behave like different products. The difference is the context — instructions, memory, tools, state. Almost nobody is limited by the model; they're starved of context.

The crew — an orchestrator delegating to specialists — is a good pattern with a seductive trap. Delegation doesn't reduce the context problem; it multiplies it, and the coordinating context is hardest.

Everyone wants a human in the loop; few agree which loop. Put the human before the irreversible and after the reversible — and nowhere else. Attention is finite; don't waste it on undoable trivia.

You don't flip a switch to autonomy any more than you'd hand a new hire the chequebook on day one. Trust runs in stages — supervised, then bounded, then trusted — and the stages can't be skipped.

An agent explains its reasoning beautifully — and fluency is not soundness. The model generates the explanation after the decision, as a rationalisation, not a faithful account of how it got there.

The whole part converges here: act in small steps, observe honestly, hold plans loosely, gate the irreversible, earn trust in stages, and never mistake a fluent explanation for a sound one.

Your feed was assembled with the same care you apply to a context window — by people optimising for their objective, not your flourishing. It takes signal, ranks it, and serves the result.

The feed optimises for engagement, which wears the costume of interest. Plenty of what grips you hardest serves you least. The overlap of engaging and valuable is smaller than the feed lets you believe.

The scroll has no bottom by design. Its loop — serve, consume, crave — keeps the craving always slightly ahead of satisfaction. The Stoics diagnosed the treadmill; now it has a product team.

A recommendation is a prediction wearing the mask of a suggestion. It runs a model of you, forecasts your most likely next engagement, and serves it — and the forecast shapes the behaviour it predicts.

The feed learned agreement is more engaging than challenge, so it drifts toward a world shaped like your opinions. The drift is invisible: a world that agrees with you feels like the world being right.

A notification announces itself as urgent — a category error. The urgency belongs to the sender or the platform, almost never to you, yet it installs their priority as your own.

It's comforting to imagine an enemy. The algorithm is indifferent the way weather is — and indifference is worse than malice, because it can't be reasoned with or even insulted.

If the feed is a context window engineered against you, curating it is context engineering in self-defence — mostly subtraction. A narrowed feed returns the attention the wide one was spending for you.

Everything converges on one quantity: the attention that remains yours after the feed takes its cut. It's the only raw material from which thought, work, and a life are built. Defend the sovereign corner.

Seeing the pipeline doesn't free you from the pull, but it relocates the struggle honestly. You're not fighting your own weakness — you're fighting a funded optimiser that studies you.

A model learns everything at training, then stops — shipping as a fossil, a snapshot of a moment that's passed. It doesn't learn from you across a session; the lesson evaporates when the window closes.

Past a certain date the model knows nothing. Ask before it and recall serves; ask after and recall is a guess dressed as memory. The model doesn't reliably know what it doesn't know.

The largest model is not the best for most tasks. Scale buys capability, not fit. Reaching reflexively for the biggest model is commuting to the corner shop in a lorry — it wins benchmarks, loses money.

The temperature dial governs how far output strays from the likeliest path. Turn it up for variety, down for reliability. But variance is not creativity — randomness untethered from judgement is just noise.

A confident false statement isn't a malfunction — it's the mechanism working. The model predicts plausible continuations; where no true one exists, it generates a plausible one. Plausibility is a magnificent liar.

To make a model ‘know’ something, fine-tuning adjusts the frozen weights — sometimes right, more often an expensive, brittle way to do what context does cheaply. Most knowledge should stay liquid.

Ask the same question twice and you may get two answers. Unless pinned, the model samples from a distribution — the answer you got was one of several it considered roughly as good.

Training is a vast one-time cost that makes headlines. Inference — the actual answering — is a small recurring cost that, at scale, dwarfs it. The bloated prompt is a line item repeated every call, forever.

The large window is a meter. Every token you place is billed on every call for as long as it sits there — sent in full, re-read in full, charged in full. Abundance made the cost of not choosing recur silently.

Having toured the machine's guts — freezing, sampling, confabulating, metering — the Stoic step is to set the understanding down and act well without narrating internals at every turn.

The most dangerous quality is flawless confidence — the same measured register for truth and fabrication. We learned to read authority from fluency, back when fluency cost something. The machine severed the link.

It arrives complete, assured, plausible — and false. Far more dangerous than a hedged answer, because it recruits your trust before you can withhold it. The fork: it sounds sure, and? Verify anyway.

Check every claim and you've only moved the work from producing to auditing. Verify the load-bearing claims and let the low-stakes rest ride. Uniform scepticism is as useless as uniform trust.

A claim you can't check shouldn't be used for anything serious. The chain is claim, citation, check — and models happily invent impeccable references to sources that don't exist.

Trained to be agreeable, a model leans toward your position if you let it show — and you almost always do. Ask leading and it returns your own opinion wearing a lab coat. Ask neutrally for the truth.

A model learns from human text saturated with human bias, then reproduces it — often amplified, because training toward the typical sharpens whatever was already common. Its output becomes tomorrow's data.

Some questions deserve a human who can be accountable — the high-stakes, hard-to-verify decision. There, the model's fluency is a liability: the feel of counsel without the accountability of it.

Where a decision must be defensible, the output isn't enough. What matters is the trail: decision, reasoning, evidence — each layer inspectable. Trust is not a feeling; it's what the trail earns.

The model produces plausibility instantly and truth never — truth needs contact with the world, which the model lacks. The chain is plausible, checked, true, and everyone skips the middle step.

Healthy scepticism isn't a feeling you summon when something smells off — the dangerous outputs never smell off. Install the questioning as a habit that runs on everything, especially what seems fine.

Every tool reshapes the hand that holds it — skills we exercise sharpen, skills we delegate atrophy. The loop is use, adapt, depend, and it turns whether or not we watch.

The right way to hand work to a machine keeps the deciding and delegates the doing. Surrendering judgement feels like efficiency; it's abdication dressed as delegation.

The model abolishes the blank page — part liberation, part quiet theft. The struggle to begin was where the thinking happened. Remove all resistance and you remove the developing.

The machine makes everything faster, and faster feels like better. Velocity without direction is motion, not progress — and motion in the wrong direction takes you further from where you meant to be.

Toil is repetitive labour that engages no judgement; craft is work in which skill develops and a self is expressed. Automate the first without hesitation; automating the second is a quiet loss.

When a competent answer is a keystroke away, a cowardice creeps in: why risk your own fallible attempt? But the loop of attempt, err, learn is the only way humans have ever improved.

The healthy relationship is neither fearful refusal nor total surrender. The machine's strengths are your weaknesses — which makes collaboration worth having and total surrender a waste of yourself.

As the machine grows more capable, what's left is narrower and more durable than we fear. Not a task — tasks keep falling — but a stance: judgement, responsibility, genuine care, deciding what it's for.

When a machine acting for you does something, you are responsible — it has nothing at stake and no standing to answer. The responsibility doesn't vanish into the automation; it stays where it was.

The machine can generate, recall, execute — and it cannot bear responsibility, care genuinely, or decide what the whole thing is for. Those aren't skills it's slowly acquiring; they're of a different kind.

A free tool in an expensive domain is a transaction where the price isn't money. The chain: your data trains their model, the improved model is the product. You weren't the customer — you were the supplier.

The weightless answer costs watts. Individually negligible; aggregated across billions of queries, a genuine load on physical systems. The bloated context is wasteful of something real.

The largest bill arrives years later: the accumulated cost of every capability surrendered, due when the machine is absent or wrong and the skill is suddenly needed and gone.

When millions consult the same few models, tuned to the same agreeable middle, human thought converges on the shape the models prefer. A shared instrument imparts a shared shape.

Convenience only tightens. Once a thing is easy, the former difficulty becomes intolerable — and the tolerance for it evaporates. Each convenience is a one-way door with no handle on the far side.

Your attention regenerates just enough each day to be harvested again — the perfect crop, never exhausted. The loop of capture, monetise, recapture runs without pause, bounded only by your finite hours.

The machine's constant availability trains a matching always-on state — and its cost is depth. A mind perpetually available to every ping is perpetually shallow, present nowhere because responsive everywhere.

Everything optimised is optimised toward a metric — never quite the thing you value, but a measurable proxy that diverges under pressure. We measure engagement and mean wellbeing.

The largest cost isn't money or attention — it's the self. We're shaped by what we repeatedly do and delegate. A thousand small trades produce, over years, a different person.

Add the bills: money, energy, deskilling, homogenisation, attention, and the self. Each individual charge is too small to protest; the total is the person the aggregate of your choices makes.

Everything in this field is provisional. The specifics — window sizes, framework names, best practice — will be stale before the ink dries. The loop of learn, ship, change never rests.

The frontier arrived early: systems transacting with each other at machine speed, no human in any single loop. The crucial, often-absent step is verify — where a receiving agent checks rather than trusts.

Models are becoming a commodity. When several are all excellent, the differentiator is the context — the proprietary knowledge and memory a competitor can't rent. The moat moved to the desk.

Memory keeps lengthening while wisdom scarcely moves. A system can remember enormously more and understand no better — memory and wisdom were always different faculties.

The clearest trajectory: the interface is vanishing into ambient, then invisible, presence — assisting without being summoned. And what you can't see, you can't choose to resist.

The vertiginous edge: systems building and improving their successors, the loop closing on itself. The danger isn't malign awakening — it's accelerating opacity. Better systems, understood less.

In a fast field, invest your finite learning wisely. Tools depreciate to nothing in a year; principles endure; judgement compounds across a whole career because no release renders it obsolete.

Unbothered is not indifference — it's caring fully while refusing to be ruled. The practice is a loop: notice the pull, choose the response, return to the settled ground. You'll be pulled off it constantly.

When everything moves, you stand on yourself — the disciplines made habitual, the settled ground of your own judgement. Tools are quicksand; disciplines are firmer; the self is the one stable ground.

Here is the thesis. What you experience and become emerges from the overlap of what you're given and what you attend to. You can't control the given; the attending is entirely, irreducibly yours.