Utopic e/λ @UtopicDev

@Hesamation But the price remains the same. 😂🤷‍♂️

x.com/i/article/2072…

// AutoMem // I quite like this idea of metamemory. (bookmark it) This new research from Stanford treats agent's memory management as a trainable skill instead of a fixed module. The model decides what to encode, when to retrieve, and how to organize its own notes, with file-system operations promoted to first-class actions right alongside task actions. AutoMem automates this on two loops. A strong LLM reviews full trajectories and rewrites the memory structure (prompts, schemas, action vocabulary). Then the agent's own good memory decisions across episodes become training signal to sharpen its proficiency. Optimizing memory alone, without touching task-action behavior, lifts the base agent 2x to 4x on Crafter, MiniHack, and NetHack. That is enough to make a 32B open model competitive with Claude Opus 4.5 and Gemini 3.1 Pro Thinking. For long-horizon agents, memory is a high-leverage objective you can train for on its own. Paper: arxiv.org/abs/2607.01224 Learn to build effective AI agents in our academy: academy.dair.ai

If you build with MCPs, this one is worth reading. (bookmark it) The paper covers five recurring MCP server patterns across fifteen independently developed servers. That taxonomy is useful because I see many AI teams rebuilding the same shapes without shared names. If you are building MCP servers, this is a practical reference for deciding whether your server is exposing resources, orchestrating tools, managing sessions, aggregating proxies, or adapting a domain workflow. Paper: arxiv.org/abs/2606.30317 Learn to build effective AI agents in our academy: academy.dair.ai

Great paper on managing agent skills. Skill libraries keep growing, and picking the right skills has become a bottleneck for coding agents. The defaults are to expose the agent to the whole skill collection, or retrieve skills with embeddings and rerankers. Both treat the choice as independent picks. SkillComposer treats composition as one joint decision over which skills, how many, and in what order. A constrained autoregressive decoder over skill identifiers produces the full plan in a single pass, so dependencies between successive skills fall out naturally. On SkillsBench with GPT-5.2-Codex and Gemini-3-Pro-Preview, it lifts pass rate by +23.1 and +18.2pp over no-skill, beats top-3 retrieval, and matches the gold-skill upper bound at lower prompt-token cost. Paper: arxiv.org/abs/2606.32025 Learn to build effective AI agents in our academy: academy.dair.ai

Hermes Agent v0.18.0 - The Judgement Release Changelog below:

x.com/i/article/2072…

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build. Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention. The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention! Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on. The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience. When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful. AI-native teams are increasingly using AI to help shape product direction, for example, automating the gathering and analysis of usage data, summarizing written and verbal customer feedback, or carrying out competitive analysis. However, for pretty much all the products I’m involved in, I see humans as having a significant context advantage over current AI systems — we know a lot more than the AI system about the users and the context the product has to operate in — and thus humans play a critical role. Many people describe this human contribution as “taste,” but I prefer to think of it as humans having a context advantage, since that gives us a clearer path to helping AI systems get better. This also speaks to why this step can’t be automated: So long as the human knows something the AI does not, human-in-the-loop is needed to to inject that knowledge into the system. External feedback loop: This includes a wide range of tactics like asking a few friends for feedback, launching to alpha testers, or putting the code into production with A/B testing. These tactics are usually slow, rarely taking less than hours and sometimes taking days or even weeks. This data informs the developer vision, which in turn continues to drive the detailed product spec, which in turn drives the coding agent. With coding agents speeding up software development, more engineers are starting to play a partial product management role. For many engineers who are growing into this role, the hardest part is shaping the product vision and striking a balance between building (bridging the gap between vision and spec) and getting user feedback to evolve the vision. It is important to do both! I will write more about how to do this in future posts, but for now, I find it encouraging that engineers are playing an expanded role (just as product managers and designers now do more engineering). [Original text: The Batch]

x.com/i/article/2071…

"I don't prompt my agent anymore — I write the loop that prompts it." Loop engineering is the meme of the month. But here's the question under the hype: a loop that runs while you sleep isn't automatically a loop that learns. Whether experience survives each cycle depends entirely on where it lands. We just dropped a survey on exactly that — how deployed agents in the Era of Experience turn interaction traces into durable capability, from self- to meta-evolution. Last time we argued: you don't pick a model, you pick a benchmark — the reward that shapes where it evolves. This is the promised self-evolution follow-up. The loop is only as good as the infrastructure underneath it. Full map 👇 💻 GitHub: github.com/FrontisAI/Awes… 🌐 Site: frontisai.github.io/Awesome-Self-I… 📄 Paper: openreview.net/pdf?id=IUltZSg…

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes: 1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship 2. Builder: quickly turns a prototype/idea into production-grade product/infra 3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance 4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit 5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS. A healthy team needs a mix of these, depending on the product: - A product that is new and pre-PMF needs people that are strong at 1+2+3 - A product that is growing and has found PMF needs 2+3+4 and some 5 - A product that has strong PMF needs 3+4+5 and some 2 Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

x.com/i/article/2070…

x.com/i/article/2070…

As agentic LLM capabilities robustify, the autonomous discovery bottleneck 💡 shifts from prescribing workflows to designing operating envs 🌎 EurekAgent 🧬 takes an agent env-centric perspective: 1️⃣ Framework: 4 design dimensions (permissions, artifacts, budgets, human-in-the-loop) shaping agent behavior through constraints. 2️⃣ Secure Isolation: Containerization with hidden evaluators accessible only via APIs, plus same-round agent isolation + controller-owned result files. 3️⃣ Agent Collaboration via Artifacts: Leverages filesystem and Git history as shared memory, enabling parallel agents to learn from each other's solutions. 📝: arxiv.org/abs/2606.13662 🧑‍💻: github.com/THU-Team-Eurek…

“I've used GEPA successfully in the context of pretraining data curation at Microsoft AI, so I thought I'd give a brief overview of why I reach for this tool :)”

Harold Benoit @harold_matmul

a week ago

x.com/i/article/2069…

1 16 155 48K 313

Andrej Karpathy: "Remove yourself as the bottleneck. Maximize your leverage. Put in very few tokens, and a huge amount of stuff happens on your behalf." loop engineering is the exact thing that gets you there. in a hand-run session you do two things. you decide what the agent runs next, and you check its output before the next step. both are manual, and both are the ceiling on how far the agent gets without you. loop engineering moves both steps into the system. the diagram below shows the operating structure that surrounds the loop: → a trigger decides what to run, whether that's a message, an event, or a schedule, so the agent starts without you there to kick it off. → the loop is the maker that produces the work, thinking, acting, and observing until it's done or the brakes stop it. → a separate checker grades the output, because a model grading its own work justifies what it already did instead of catching where it failed. the checker's findings return to the maker as the next instruction, and the cycle repeats until nothing is left to fix. → state lives on disk, not in context, since the model forgets everything between runs. an MD file or a knowledge graph holds what's done and what's still open, so a loop can pick up again days later. for that state layer, Zep's Graphiti is a clean open-source option, a temporal knowledge graph that invalidates stale facts and returns context through vector, full-text, and graph search in one call. repo: github.com/getzep/graphiti two things decide whether an unattended loop holds up. the exit has to be set before the loop runs, not while it's running. a loop with no stop condition burns tokens, and the cost climbs fast once sub-agents and long runs stack up. a clean exit reads like "all tests pass and lint is clean, stop after two passes." and the checker only catches failures inside a run. the harness around the loop, the prompts, tools, and checks wrapped around the model, still drifts and breaks in production as models change. catching that needs observability on every run, not a green checkmark. Comet's Opik is built for that layer, an open-source tool that traces every call and turns a failing production trace into a regression test so the same break can't recur. repo: github.com/comet-ml/opik your job stops being the hands inside the loop. it becomes designing the machine that runs without you, then watching the traces closely enough to trust it. the model is becoming a commodity. the loop around it is where the real engineering lives now. I wrote the full breakdown. the article is quoted below. stay tuned for more on this!

Akshay 🚀 @akshay_pachaar

a week ago

x.com/i/article/2069…

40 244 2K 1.1M 4K

// Agent memory is a data system now // Great paper on long-term memory for LLM agents. (bookmark it) Agent memory has grown from simple retrieval into a full data-management layer with storage, retrieval, update, consolidation, and lifecycle governance. Yet most evaluations still score it as a black box through end-to-end task success like F1 and BLEU, which hides the costs and failure modes underneath. The authors decompose agent memory into four core modules and measure each one for operational cost, architectural trade-offs, and robustness under dynamic knowledge updates. Why does it matter? If you design an agent memory layer, this gives you the module breakdown and the system-level metrics to evaluate it honestly, instead of trusting a single downstream score. Paper: arxiv.org/abs/2606.24775 Learn to build effective AI agents in our academy: academy.dair.ai

Introducing the OpenRouter MCP, live model intelligence right inside your agent Your agent builds and ships, but when it comes to choosing the right model for the right job, it guesses from 6 month old training data Watch it pick, price, and test the right model:

Hermes /learn explained. agents usually learn the hard way. they struggle through a task live, fail a few times, find the path that works, and only then write down what they figured out. the lesson costs you a painful session before it becomes reusable. Hermes Agent by Nous Research just shipped /learn, and it removes that struggle from the front. point it at a source and it builds a skill before it has ever run the task. a local SDK directory, a docs URL, a workflow you just walked it through, or a procedure you paste in as plain notes. it reads the material, writes a 𝗦𝗞𝗜𝗟𝗟.𝗺𝗱, tests the skill live, and saves it. so /learn an internal REST client, tell it to focus on auth and pagination, and you get back a skill that covers exactly that, ready to invoke as a slash command. here is the part worth understanding. Hermes already created skills on its own. after a complex task or a recovery from a dead end, a background pass would quietly capture what it learned. that loop only fires on completed work, so it learns from trajectories the agent has already finished. /learn is the deliberate version. you invoke it, and it learns from material the agent has never touched. docs it has not read, a repo it has not run, someone else's runbook. the mechanism is the cleanest part. there is no separate ingestion engine. /learn builds a standards-guided prompt and hands it to the agent as a normal turn. the agent gathers the material with tools it already has, then authors the skill and saves it through the same skill tooling. because it is just a turn, it works everywhere the agent does. the CLI, the messaging gateways, the dashboard, with nothing new to deploy. the advantages stack up from there. → onboarding collapses to one command. a private API that meant re-reading the docs every session becomes a skill your whole team invokes. → a repo turns into a playbook. point /learn at a codebase and it captures the patterns and workflows, so the next session starts from how to work with it. → a one-time walkthrough becomes repeatable. deploy the staging server once, /learn it, and the procedure outlives the session. → the output is verifiable. every skill ships with a verification section and gets tested live before saving, so you get a draft that already ran. memory remembers facts. skills remember how to do the work. /learn is the front door to the second one, and it lets you fill that store on purpose instead of waiting for the agent to earn each entry the hard way. the best builders stopped re-teaching the agent the same procedure every session. they hand it the source once and keep the skill. That said, if you’re looking to set up Hermes, I wrote a full deep dive covering the Hermes agent’s architecture, memory system, self-evolving skills, GEPA optimization, and how to set up multiple specialized agents. The article is quoted below. You can also watch my YouTube crash course on the Hermes agent: youtube.com/watch?v=bNp6Yc…

Akshay 🚀 @akshay_pachaar

2 months ago

x.com/i/article/2053…

119 795 6K 5.6M 23K

@everestchris6 REEL