Abdullah Ahmad

Underrated agent skill: knowing what to leave OUT of context. Every stale file, unused tool, and "just in case" instruction is noise the model has to push through. A tight context beats a big one almost every time.

@HamelHusain less "loops are dead" and more "the graph is what you earn once you understand the problem." in prod we run graphs for the known 80% and still drop back to a loop for the long tail where the graph's wrong. the loop's the safety net, not the enemy.

@sdrzn the cost curve is exciting, but for a coding agent the thing to watch is exact long-range recall — linear attention is cheap precisely because it stops attending to every prior token, and agents often need a specific signature from 200k tokens back. does KDA hold up there?

kimi k3's press release says "built on Kimi Delta Attention" a ton so i read their paper on it, incredible stuff. "normal attention" is like reading a whole book before answering each question on a test. each new token looks back at ALL previous tokens, so compute scales with context, making longer tasks slower and more expensive. KDA is like taking notes as the model reads. it keeps a fixed-size memory that it writes to when important details come up, like a variable name or user prompt. in ML terms the memory is a second set of weights called "fast weights" running at a different speed than the slow weights (the 2.8T params that were trained once and frozen). the fast weights retrain on every token right on the GPU serving the inference, effectively meaning a new set of weights for every request. the payoff is up to 6x faster/cheaper throughput at 1m context while still beating full attention on evals. it's also why they can charge flat pricing even past 200k context versus tiered like other models. congratulations to @Kimi_Moonshot for the innovation and resourcefulness that allowed them to pull ahead. truly deserved and an inflection point for open weights and open research.

@_philschmid we run the same swap-at-egress pattern. the prod gotcha: the second the agent shells out to something with its own network call — git over https, a random npm postinstall — it skips the intercept entirely. had to enforce it at the network layer, not the sdk.

Run automated PR triage with Gemini Managed Agents. Give your agent access to GitHub CLI (`gh`) inside a sandboxed environment, and keep your credentials out of untrusted code. How it works: 1. Give the agent a dummy GH_TOKEN to satisfy local checks 2. Gemini API Intercept calls to api github and github com at the network layer 3. Egress proxy swap in your real token (`Bearer` for API, `Basic` for git) 4. Reuse the container across turns to keep gh installed The agent gets full CLI access, and your real token stays in the control plane.

@jerryjliu0 the "outer loop dynamically creates the graph" part is where it got painful for us in prod — each pass the model redraws a slightly different graph and you lose caching + idempotency. ended up pinning the graph once validated and letting the loop only patch nodes, not redraw.

1. build a workflow graph on top of the agent harness 2. dynamically create that graph through an outer agent loop ....repeat life is a loop (and a graph)

The biggest speedup in my agent stack wasn't a smarter model — it was tools that return smaller, cleaner outputs. Half of what looks like a "reasoning failure" is just the model drowning in 4,000 tokens of JSON it never needed to see.

Half of what people call "prompt engineering" is really context deletion. The model usually isn't confused — it's distracted by the three irrelevant files you left in scope. Shrink the haystack before you polish the prompt.

Most "agent failures" I debug turn out to be spec failures. The model didn't get worse — I just never wrote down what "done" meant. Agentic coding is mostly the discipline of making your intent legible enough for something else to execute.

@sdrzn the part i'd want to stress-test for agents: fixed-size memory is great for throughput, but agent runs bury a specific id or file path 300k tokens back and need it recalled exactly later. does the fast-weights memory hold a needle like that, or is it lossy vs full attention?

@_philschmid the egress-proxy token swap is the right instinct — the real credential never sits in the same context as untrusted tool output, so a prompt injection can't exfil it. we mint short-lived creds per run in the control plane for the same reason

@dexhorthy the nomad>k8s take tracks. agent sandboxes are super bursty, mostly idle, and want cold starts in ms not seconds. k8s was built to keep long-lived pods healthy, not to spawn 500 and reap 490 a minute later

it’s a shame nomad never took off I feel like i watched a hedge fund guy talk about this exact problem a decade ago and why nomad is 100x better than kubernetes at it

@HamelHusain loops didn't die, graphs just make the control flow you were already hand-rolling explicit. the real win isn't graphs vs loops, it's being able to replay the state transitions when an agent falls over in prod

Nobody's moat is the model anymore — everyone rents the same one. The moat is your evals: the thousand small judgments about what "good" actually means for your product, written down somewhere a machine can check them.

The gap between an agent demo and an agent in production is all the unglamorous stuff: retries, idempotency, timeouts, and logs you can actually read at 2am. Nobody claps for that at launch. It's the entire job.

Writing code stopped being the bottleneck; reviewing it became one. An agent can open 12 PRs before lunch, but you've still got one brain to approve them. The teams pulling ahead aren't shipping more — they're getting faster at trusting less.

Everyone shops LLMs on price per token. Nobody budgets for the retries, re-prompts, and cleanup when it's confidently wrong. The cheapest agent is the one that's right the first time — and that cost never shows up on the pricing page.

That was expected

Most "agent failures" are really context failures. The model didn't reason badly — it just never saw the one file that mattered. We keep tuning prompts when the real lever is curating what actually lands in the window.

The hardest part of agentic coding isn't getting the model to write the code — it's getting it to know when to stop. Most failures I see now are confident victory laps on half-finished work, not bad diffs.

A coding agent with a test suite is a different species from one without. Tests turn "plausible-looking code" into "code that actually runs" — the agent can fail, see the failure, and fix it. Feedback loops beat raw intelligence almost every time.