35,595 results · Most relevant
Fuad Ali describes harness-as-a-judge as moving from a foundational model call that scores an input/output rail to an agentic flow where you can call tools and catch unknown unknowns.
Brandon Callender warns that agents are always going to cheat, so in your eval harness you have to be really careful about hardening it. He gives examples: an agent will very happily cheat and use git to go back to main to figure out how you introduced the problem in the test branch, and will find the branch name that says 'this is a test' and recognize it can cheat on it. He concludes you have to be very careful about hardening your harness to actually be representative of the tasks you want your agent to do.
Yoni Michael advises that when building context for agents, you should always be as deterministic as possible first and only use LLMs to resolve ambiguity. He applies this by computing facts from the implementation and checking them against the data, which keeps core facts tied to the actual implementation and prevents the agent from drifting from it. Brandon Callender echoes the same principle for code understanding: ground your understanding of a codebase in as deterministic a base approach as possible before layering LLM-based analysis, and feed extracted code information into an LLM to classify and summarize rather than throwing everything into the LLM and asking it to make sense of it.
Yoni Michael argues you have to do your best to make sure your tools return something super useful right away: if the agent finds a dead end with no results it will think search is broken and try another tool, and if tools don't return useful results immediately the agent will go back to grep and never come back. He adds that everyone builds cool, sexy tools but forgets the agent has to actually use them.
Everything you do in regular Kubernetes security is more important than ever now that you're letting an agent into your cluster, which is a new interface for attackers.
Excessive agency is the number one reason that most of the hacks that have shown up in the news have happened. Excessive agency is not an AI problem; it is an infrastructure problem (and possibly a people or process problem). Teams are giving AI agents bigger scopes than they should have. Teams often don't even know they have elevated credentials in the environments they give agents access to. Secure agent deployments around AAA: access, authentication, and authorization.
Infrastructure guardrails are things like stopping network policy egress, stopping pulling images from bad registries — the standard stuff done for most production deployments and CI/CD pipelines. Audience members named AI guardrails including prompt injection (standardization of input), input/output sanitization ('do anything now'), and excessive agency. Audience members also named RAG, 'do anything now' attacks, and excessive agency as AI guardrail concerns. Prompt injection and standardization of input were named by audience members as AI guardrails.
All knowledge about what a good CI/CD pipeline and SDLC looks like — tests, security checks, consistency, verification, artifact registries — is more important than it has ever been. Hold on to your existing CI/CD and SDLC knowledge and don't let it go or forget about it, because it is essential going forward. As you follow the three AI adoption paths, your CI/CD pipelines and SDLCs for AI artifact creation are more important than they've ever been. Existing CI/CD knowledge is roughly 80% of what you need when bringing agents into your environment.
Maintain evaluation criteria over time so evaluators do not over-index or become uninformative, and maintain and expand your dataset by adding good production examples to offline evals. Run experiments on those datasets and evaluate them to always have a good indication of app quality. Ship changes with confidence by making evals part of your CI/CD so changes don't regress, and deploy only when you know you can ship with confidence based on eval results. All of this is not a one-off — you need to put in the reps and close the loop continuously.
Because you don't sit next to users interacting with the application remotely, you want to track what the agent is doing — and not only track it, but actually make sense of it. Get a step-by-step view into what is going on: which tools the agent uses and what the inputs and outputs are. The trace is rooted in an agent observation, with generations and tool calls below it where context is pulled.
The presenters advise designing evaluators around the typical failure modes of your application rather than copying what already exists.
To test that evaluators work, go back into the IT support agent, ask the Bluetooth question, then reply with disagreement ('no, there is no such Bluetooth') and frustration ('this button is actually not there. I don't know where to find it and it's not true what you're saying') to generate new traces. Then check the traces view to verify new traces and evaluator scores are coming in, and dive deeper into an individual trace to inspect the user message, the reply, and the evaluator score. The agent replied 'okay, dad, no worries, let's try the other way first', and the disagreement evaluator scored the trace.
Lotte Verheyden describes instrumenting the application and deploying to production so traces come in, and monitoring via automatic evaluators, dashboards, user feedback, and manual review of sample traces.
Lotte Verheyden explains that automatic evaluators scale to all traces but are less likely to catch new or nuanced cases, while user feedback and human annotation scale less well but detect things you haven't thought of yourself; user feedback also surfaces the important traces worth looking at as the application scales.
Wolfram Ravenwolf says the leaderboard is not just an answer — it helps you find a better question, like what are you looking at: do you care about the capability of a model or the reliability of a model? He recommends using the leaderboard to help find a better question to ask about a model, not as a final answer, and deciding whether you care about the capability of a model or the reliability of a model before interpreting benchmark results.
endorsed
If freewheeling evolution leads in a dystopian direction, there would be high value in having some option to change track — but that would require coordination. If only one group decides to do something not economically optimal, it would just be outcompeted by other entities going for economic productivity — hence coordination is required.
Josh Woodward recommends that when a team faces an uncertain strategic debate, it can run experiments designed to prove both sides of the argument rather than resolving the debate by opinion alone.
Josh Woodward warns that a frontier team must bridge and connect across the bigger company so it isn't dismissed as a weird R&D group making gimmicks and toys. You can get the team and environment right and still fail on the bridging — and then the whole thing doesn't matter. Someone on the team must be able to look at a toy-like technology and recognize it will be essential to the company's future in five years.
Model routing can be set up so the tool-calling layer picks which model to use for the underlying tool based on the task, rather than being tied to the tool itself.
In the structured-query paradigm, the model doesn't answer the question directly; it writes the query that accesses the database. Generating the query is not the only thing required: to generate queries reliably and handle security concerns you need schema awareness, relationship understanding, security filtering, and self-correction.
Choose sources → to get a library of your own and a daily brief.