- All
- Riteangle 17
- Decision systems 10
- Agent architecture 8
- Operations 8
- Context engineering 6
- Guardrails 6
- Data platform 5
- Agent evals 4
- Agentic architecture 3
- Advertising 2
- Marketing 2
Riteangle — 17 posts
Nine attribute vectors instead of embeddings, and the pure scoring function that makes counterfactuals exact
An embedding can tell you two people are close and cannot tell you which of five hundred axes did the work, because the axes mean nothing individually. When the output is a ranking that decides who someone meets, the question that matters is not who is similar but what would change the answer. Hand-designed dimensions with a pure scoring function make that exact rather than plausible — and let sensitive attributes be excluded by a weight pinned to zero instead of by a promise.
9 min read
Agent replay with writes suppressed at the boundary, and the side-effect ledger that proves nothing escaped
To debug an agent you need the prompt it actually saw, and the only way to get that is to run it — which sends messages to real people. This harness is the production code path with the writes cut at the boundary, and every suppressed effect recorded in plain language rather than silently skipped. It is very good at showing you one turn and completely unable to tell you whether that turn was any good, which is the state most eval work is actually in.
8 min read
NULLS FIRST and a client insert default corrupted an agent's context window for nine turns running
An agent's context window is a query result, and it is the one artifact nobody audits — assembled at runtime, used once, discarded. Two separately correct, separately documented library defaults met in the middle and pinned a single old message to the top of every window, so the agent read it as the newest thing said and escalated accordingly. This is what that failure looked like, why every natural diagnosis pointed at the prompt instead, and how you test for a bug that lives in the gap between two libraries.
8 min read
Deterministic overrides after generation, and the incident behind each one that a prompt could not prevent
A prompt is an instruction, not a constraint, and a model told ten times not to do something will still do it on the turn where the sentence felt right. Worse, a refusal is a property of one model call and does not survive being wrapped in an orchestrator. So the rules that actually have to hold live in code that runs on the output — five checks, each written after something went wrong in production.
9 min read
LLM-as-judge in the send path, and the human-label calibration that gives its score an error bar
Once a system generates text faster than anyone can read it, the choice is between shipping unreviewed output and building something that reviews it — and human review does not scale to every message while sampling misses exactly the rare failures worth catching. A small model grading a large one costs a fraction of the thing it guards, which is what makes total coverage affordable rather than aspirational. The catch is that a judge nobody has scored against human labels produces a number with no error bar, and a confidently wrong judge looks exactly like a working one.
21 min read
A 48-hour hand-off that expires without deleting, and the single clock the cron and the agent both read
An agent finishes its work and hands the result to a person, which leaves a third party waiting on someone who may simply be busy. A deadline is necessary to protect them; a deadline that deletes punishes the wrong person for a scheduling accident. The resolution is that expiring and deleting are different operations, and the timeout should do the smallest thing that frees whoever is waiting.
9 min read
Data, prompt, context, loop and harness engineering: the tooling, cost and failure mode of each layer
Most failed agent projects are a data problem with an orchestration budget: a team buys a framework, builds an elaborate loop, and discovers the underlying data was six hours stale and nobody owned the definitions. These five disciplines arrived in sequence, each because the previous ran out of road, and each has a different unit of work, cost profile and characteristic failure. The last one is the only one whose purpose is to make the system smaller.
12 min read
Kafka to MCP in twenty-four months: what the agentic wave added to the data stack, and what it left untouched
The story everyone tells is that AI replaced the data stack. Two years of attending India's data and AI conferences says something more useful: Kafka, Spark, Airflow, dbt and Iceberg run unchanged from May 2024 to May 2026, four new floors were built on top of them, and the layer that actually got displaced was business intelligence. If you are deciding whether to rebuild your platform to do AI, the evidence says the work is above your serving layer, not below it.
8 min read
Twenty context blocks assembled per turn, and the output schema derived from which ones arrived
Prompts built by string concatenation at the call site drift from whatever you tested, and the context an agent actually saw is thrown away the moment it replies. Here assembly is a subsystem: twenty blocks loaded in parallel, volatile facts grounded in SQL rather than recollection, and an output schema derived from which blocks arrived — so the model is never asked for a field this turn cannot fill. Nothing in it counts a token, which is the honest gap.
10 min read
A fail-closed regex and a fail-open model judge on every message, and the single corrective retry between them
An agent writing on someone's behalf produces text a real person reads and attributes to a real person, and nobody can read all of it before it goes. Sampling misses exactly the rare failures worth catching. A small model grades every outbound message against an enumerated rubric at roughly a sixth of the generator's budget, which is what makes total coverage affordable — and the uncomfortable part is that nothing has ever checked whether the grader is right.
12 min read
Cross-thread agent memory with provenance omitted at schema level, so shared recall cannot leak its source
When one person is represented by several agents, each working for a different counterparty, he answers the same question over and over — and the obvious fix, shared memory, quietly tells each agent about conversations it was never part of. The value and the hazard come from the same fact. This is a memory store where the origin of a row was never recorded in the first place, so it cannot be recovered by a query, an agent, or anyone with database access.
12 min read
Min-cost max-flow picks the match, and the confidence multiplier that keeps an unproven claim at 30% of its weight
A generative model cannot be regression-tested, cannot explain a specific past output, and cannot be told apart from its own drift — which makes it the wrong thing to put in charge of who two people meet. So the models here read evidence and write messages, and a weighted dot product plus a flow solve makes the actual call. The payoff is that any ranking can be re-derived exactly by changing one input and running it again.
12 min read
Meta ads, loop engineered
Half the button presses were never reaching Meta, and the screen that would have fixed it was greyed out. The way through was an error message that refused the right thing for the wrong reason.
9 min read
Snapchat advertising, loop engineered
A dashboard tells you what happened. A loop makes the next decision better than the last one. Here is the whole arrangement for one ad account, including the half of it that is still open.
7 min read
What it takes to measure one tap
Four systems, none of which can see each other, cooperating to record that somebody pressed a button. Here is the whole arrangement and why each piece is there.
7 min read
Zero is not a measurement
I spent a day on a conversion number that read zero. Three separate things were wrong, and not one of them raised an error.
10 min read
Starting a notebook in public
Why I'm writing here, and what I intend to put in it.
1 min read