Most predictions I see are still way too conservative.

Here's mine

A Chinese developer just explained the shift from Loop Engineering to Graph Engineering better than anyone.

most people are still building agents the way that's about to be obsolete.

> why single-agent loops break and go "goal blind"
> the 4 parts of a graph: nodes, edges, state,that run everything: diamond, supervisor, pipeline
> Anthropic's 5 official workflow patterns

the punchline: it's not how many agents you run. it's the determinism you build with verifiers, code fallbacks, and reality anchors.

I broke the same architecture down with Kimi K3. Full A-Z guide below.

@MustStopMurad thinking the choice is AI or human.

Vibe coding and agentic workflows may get automated, just like prompt engineering got compressed into better tools. But the deeper skill is not “knowing prompts.” It is knowing how to turn ideas into products, systems, media, and leverage.

The real alpha is human, yes: community, mission, culture, belief, identity, movement.

But AI is how those movements scale faster.

So the answer is not to abandon AI.

It is to stop worshipping AI tactics and use AI to scale what machines can’t create on their own:

belief, belonging, trust, and movement.

Introducing the Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format.

AI is only as smart as the context we give it. As we build more advanced, agentic AI systems, they need accurate metadata and context to organizations, that context is locked inside fragmented data catalogs, isolated wikis, scattered code comments, or the minds of senior engineers. Every time a new AI agent is built, teams are forced to solve the exact same context-assembly problem from scratch.

To solve this, we've announced OKF, a vendor-neutral, open specification that formalizes the "LLM-wiki pattern" into a portable, interoperable format. It provides a standardized way to represent the enterprise knowledge that modern AI systems rely on.

— Just markdown: readable in any editor, renderable on GitHub, indexable by any search tool
— Just files: shippable as a tarball, hostable in any git repo, mountable on any filesystem
— Just YAML frontmatter: for the small set of structured fields that need to be queryable: type, title, description, resource, tags, and timestamp

We’ve also shipped reference implementations to help you hit the ground running, including an enrichment agent for BigQuery, a static HTML visualizer, and live sample bundles on @github → goo.gle/4uGvAEe

➕ Knowledge Catalog can now natively ingest OKF!

Stop reinventing data models and building bespoke integrations for every new AI tool. Here's more about how OKF works → goo.gle/4uGvBbg

10 things i learned about harness engineering - how to get the most out of coding agents TODAY

(shouts out to @0xblacklight for the excellent post)

Here’s what’s gonna happen:

- you replace your code review with feedback loops (sentry, datadog, support tickets, etc)
- you stop reading the code
- software factory fixes everything
- one day something breaks at 3am, agent can’t fix it
- nobody’s read the code in 3 months
- you have 3 weeks of downtime trying to re-onboard and fix it
- you lose significant % of your contracts and users
- your company is now dead

.@LakshyAAAgrawal has done an unbelievably nice job collecting successful applications of GEPA to everything from state-of-the-art research to new products and established enterprises at this page.

Staying on top of these is harder than one would think!

gepa-ai.github.io/gepa/guides/us…

My RLM video came out a few hours back!

It is currently the best performing video on my channel 7 hours into release! Yay! 🥳

Nope. My lab is making 3 algorithmic bets. One of them is on recursion, RLMs being step 1. Another one is on the power of late interaction retrieval.

Conventional single-vector retrieval was always a bottleneck, even back in 2019 when starting ColBERT. So if you're wondering if that's not ideal, it isn't. Same for single-step RAG.

But better retrieval is both possible and badly needed. Recursion is fundamentally an inference-time mechanism. You wouldn't want to recursively index a 10B-token corpus on each and every request.

The world loses millions of dollars in productivity every day that coding agents aren't RLMs yet.

Part 4 of my deep dive into hexagonal architecture in Rust is live! 🦀 Covering:

🤔 Trade-offs of hexagonal architecture
⛔️ Common pitfalls to avoid
📈 Adopting hexagonal architecture at every growth stage

Read & subscribe for updates: howtocodeit.com/articles/maste…

#Rust #RustLang

enjoy :)
medium.com/@tm23mdm/learn…

- you are
- a random CS grad with 0 clue how LLMs work
- get tired of people gatekeeping with big words and tiny GPUs
- decide to go full monk mode
- 2 years later i can explain attention mechanisms at parties and ruin them

- here’s the forbidden knowledge map
- top to bottom, how LLMs actually work

- start at the beginning
- text → tokens
- tokens → embeddings
- you are now a floating point number in 4D space
- vibe accordingly

- positional embeddings:
- absolute: “i am position 5”
- rotary (RoPE): “i am a sine wave”
- alibi: “i scale attention by distance like a hater”

- attention is all you need
- self-attention: “who am i allowed to pay attention to?”
- multihead: “what if i do that 8 times in parallel?”
- QKV: query, key, value
- sounds like a crypto scam
- actually the core of intelligence

- transformers:
- take your inputs
- smash them through attention layers
- normalize, activate, repeat
- dump the logits
- congratulations, you just inferred a token

- sampling tricks for the final output:
- temperature: how chaotic you want to be
- top-k: only sample from the top K options
- top-p: sample from the smallest group of tokens whose probabilities sum to p
- beam search? never ask about beam search

- kv cache = cheat code
- saves past keys & values
- lets you skip reprocessing old tokens
- turns a 90B model from “help me I’m melting” to “real-time genius”

- long context hacks:
- sliding window: move the attention like a scanner
- infini attention: attend sparsely, like a laser sniper
- memory layers: store thoughts like a diary with read access

- mixture of experts (MoE):
- not all weights matter
- route tokens to different sub-networks
- only activate ~3B params out of 80B
- “only the experts reply” energy

- grouped query attention (GQA):
- fewer keys/values than queries
- improves inference speed
- “i want to be fast without being dumb”

- normalization & activations:
- layernorm, RMSnorm
- gelu, silu, relu
- they all sound like failed Pokémon
- but they make the network stable and smooth

- training goals:
- causal LM: guess the next word
- masked LM: guess the missing word
- span prediction, fill-in-the-middle, etc
- LLMs trained on the art of guessing and got good at it

- tuning flavors:
- finetuning: new weights
- instruction tuning: “please act helpful”
- rlhf: reinforcement from vibes and clickbait prompts
- dpo: direct preference optimization, basically “do what humans upvote”

- scaling laws:
- more data, more parameters, more compute
- loss goes down predictably
- intelligence is now a budget line item

- bonus round:

- quantization:
- post-training quantization (PTQ)
- quant-aware training (QAT)
- models shrink, inference gets cheaper
- gguf, awq, gptq, all just zip files with extra spice

- training vs inference stacks:
- deepspeed, megatron, fschat, for pain
- vllm, tgi, tensorRT-LLM, for speed
- everyone has a repo
- nobody reads the docs

- synthetic data:
- generate your own training set
- model teaches itself
- feedback loop of knowledge and hallucination
- welcome to the ouroboros era

- final boss secret:
- you can learn all of this in ~2 years
- no PhD
- no 10x compute
- just relentless curiosity, good bookmarks, and late nights

- the elite don’t want you to know this
- but now that you do
- choose to act
- start now
- build the models

If you truly want to learn RL, ditch the readymade gym environments.

Make a custom environment on your own. You’ll understand how to structure rewards, observations, random initialization states, etc. also, how to debug and render. This is the most practical skill you can get in RL. You can literally implement any env you want - a game, a robotic control task, a text thingy, whatever you feel interested in.

For the training algorithm, start with SB3 modules as you’re building the env. This will teach you the important hyperparameters and save you the headache of debugging your env and your training at the same time (trust me don’t do this).

Then once you can see it train on your custom env, and you are confident there’s no bugs, create your own implementation from scratch.

This will teach you exploration, memory, and the actual optimization loop.

The minimal algorithms you should know are: DQN/DDQN, REINFORCE, A2C, PPO. Implement in that exact order.

There’s nothing more rewarding than training a custom agent in your custom environment. You get the full tour of RL.

If you read this far, you are ready to do all of the steps above. Take your sweet time but just do it.

@karpathy wrote about this here! github.com/humanlayer/12-…

Apple did more for AI than anyone else: they proved through peer-reviewed publications that LLMs are just neural networks and, as such, have all the limitations of other neural networks trained in a supervised way, which I and a few other voices tried to convey, but the noise from a bunch of AGI-feelers and their sycophants was too loud.

Now, I hope, the scientists will return to do real science by studying LLMs as mathematicians study functions and not by talking to them as psychiatrists talk to sick people.

Self-attention in LLMs, clearly explained:

My most elitist opinion is that I don’t care about anyone’s takes if they can’t do calculus and linear algebra. Math is the most abstract, purified form of thinking. If you can’t do that, you definitely can’t do the harder and messier thinking needed for politics, philosophy, etc