35,800 results · Most relevant
Running an LLM in a loop that keeps only the best prompt gets stuck in a local optima and exhausts the search budget without improving; repeated improvement requests produce proposals that are not actually better.
Because prompts are just text artifacts that determine AI system behavior, the same algorithm can improve anything that you can express as a piece of text and score.
GEPA fully automates the process of discovering problem specifications that human engineering teams previously spent weeks on manually, tweaking prompts word by word whenever a new model comes out.
Roman Ugarte argues that AI bots should be personified as helper entities — colleagues and teammates — rather than mere tools, and that this mindset ('colleague-pilled') should drive product decisions: ask how a human teammate would behave in a given situation, and build that experience.
Roman Ugarte argues that a cultural inability to move quickly and change to meet the moment means losing to competitors, and that a company that cannot completely reinvent itself every six months will lose.
Roman Ugarte distinguishes real delegation from pseudo-delegation: if you have to watch every step and keep iterating, you are still doing the work. True delegation is a 'no-look pass' — give context, trust execution, and don't intervene. He notes that a 90%-trusted teammate still requires your active involvement, while an AI that does 100% of the job feels categorically different.
Roman Ugarte explains that a key early decision for GrokBot was that all bot workflows run in the cloud rather than being tethered to a local machine, giving each bot its own computer with persistent state. This lets users text the bot and kick off work from their phone, and it means users never have to think about whether something is running locally or in the cloud.
Roman Ugarte argues that obsessing over moats instead of building something useful today would not have created the magic outcome; usefulness earns user trust and their time in the product.
hedged
Tejas Bhakta argues that autoresearch agents are still really bad at the high-level idea — like deciding to use a specific GPU and pipeline it — and won't come up with groundbreaking ideas. It is still up to the human to have the good ideas; the actual implementation is straightforward once the idea is laid out. His TLDR: have better ideas, then use autoresearch.
Irina describes the stateful architecture behind the agents: per-agent memory namespaces backed by RAG so memory does not bleed between agents, emotion tracked as a small vector that updates after events or conversations, and every memory receiving an importance score with high-importance memories stored in a separate cache so important context can be retrieved later. She illustrates importance-scored memory with the dinner-versus-murder example.
hedged
Irina emphasizes that when running auto-research it is important to freeze the harness, the scenarios, and the metrics so that changes are measured against a stable baseline.
The first thing Weave is used for is collecting production traffic, which is super critical to collect so you can learn and iterate.
Jemima Abu argues it's a lot harder to bake in accessibility on a fully built site — retrofitting is like shoving blueberries on a plain muffin and calling it a blueberry muffin. You cannot shove a bunch of ARIA labels into a product and call it an accessible website; accessibility must be baked in from the start.
Jemima Abu's takeaway from her experiment: when you provide skills to agents that tell them to do a thing a specific way, it will be faster and save you a lot more money in the long run.
Jemima Abu recommends providing agents with specific guidelines and constraints so they don't get lost generating unwanted output — for example, getting lost generating things with a lot of divs — and stresses making sure the finished result is exactly what you're looking for. She compares it to a parent sending a child on a first errand with a map, boundaries, and a shopping list.
Run basic sanity checks on model-generated financial models, such as: a formula can't depend on itself, and raising the membership fee needs to raise revenue. Also check that every lever in the model actually moves the output; a lever that produces zero change signals something is wrong.
If two errors are canceling out, an auditing trick to detect hidden wrongness is to fix just one of them; the model's error will then worsen, revealing that the original good result was luck. In their case, replacing AI's made-up 15% executive share with the real 45% jumped the forecast error from 1.7% to 28%.
Recovery is not considered successful merely because an undo command was run; an independent verifier must confirm the resulting state matches the original.
LLMs are smart but work when they're paired with deterministic tools and technology. Use deterministic tools that already exist to compute numbers and entities rather than relying on the model's own computation.
By creating a system where the models have to dereference their own pointers, you can actually create a very powerful, very verifiable AI platform.
Choose sources → to get a library of your own and a daily brief.