35,848 results · Most relevant
A graph is preferred over a pile of text or markdown files because the access pattern lets the agent pull exactly the subgraph it needs in one traversal, avoiding prompt stuffing and scaling past 500 models.
Make data context a first-class citizen: extract it, compute it, persist it, and let the agent query it efficiently via a graph. Providing a queryable data context graph crosses the line from an agent that only reads code to one ready to operate the data system.
Giving an agent a pre-computed, traversable graph model of the codebase alongside its existing tools does not guarantee it will use the graph tools — it may still run grep anyway.
Yoni Michael frames the tool-adoption problem: you're not competing on the merits of your tool being better; you're fighting against the agent's own reflexes. Models are trained to call grep and read because there are so many circumstances in their training where the answer is to grep. If you're naive with the prompt, the agent will just grep and do other stuff; nudging the prompt can get it to actually run the search.
The speaker advises reading all of your different traces to verify eval results, not just the scoreboard, because scoreboard-only answers can look directionally correct while burying much larger underlying issues in your architecture. The fix is never just to make the number higher; it's to build a harder eval, read the traces, find the artifact, harden the harness, and rerun.
Yoni Michael argues that agent tools must return something useful immediately: if an agent hits a dead end (no results when there should be results), it concludes the tool is broken, switches to another tool (typically grep), and likely never comes back. He frames this as a design requirement for tool builders.
The core context engineering principle: take tribal knowledge that lives in someone's head or in documentation elsewhere, compute it, and make it queryable for the agent.
You cannot make an agent prefer your better tool just by making the tool better — the agent's trained muscle memory will keep it using familiar tools. When building agent tools, you are not competing on the merits of your tool versus the rest of the agent's toolset — you are fighting against the model's own reflexes. You also cannot get a model to completely change its tool-use behavior just by prompting — it won't rewrite its own training.
Yoni Michael states that they practice eval-driven development, which he calls a very important part of building agentic systems.
Traversal always beats prompt stuffing or context stuffing; let the agent pull the subgraph it needs, which yields smaller context and more efficient AI runs.
The signal is consistent: the richer the context you give the agent, the more the outcome changes, compared to just swapping models or adding more generic MCP tools to the model.
The host argues that storing sensitive data can severely increase the impact of any security incident, and that storing less user data directly reduces the blast radius of an incident that happens.
The speakers argued that everything you know about regular Kubernetes security is more important than ever now that an agent is in your cluster, because the agent introduces a new interface for attackers. Similarly, CI/CD pipeline and SDLC knowledge — tests, security checks, consistency, verification, artifact registries — is more important than it has ever been as AI creates artifacts, and Whitney characterized this existing knowledge as like 80% of what you need going forward. They framed three distinct AI paths: AI-assisted artifact creation, adding AI to existing applications, and AI-managed systems, with AI-managed systems being the riskiest.
The 80% figure is an informal characterization, not a measured statistic.
There are three possible AI use cases: AI-assisted software development/artifact creation, adding AI to an existing application, and AI-managed systems. AI-managed systems is the riskiest of the three AI use cases.
Organizations frequently don't realize they have elevated credentials, keys, and tokens sitting in the environments they give agents access to.
Kyverno is an admission controller software that adds an admission controller webhook with your Kubernetes admission. When Kyverno gets a request that falls under the jurisdiction of a certain rule, it sends that to Kyverno running in the cluster, which has a validation engine that says yes you can deploy this or no you cannot. Kyverno comes back with a verdict telling your admission controller whether the deployment can proceed, and your kube-api does the deploying. In this case Kyverno is doing validating admission; you can also do mutating admission with it. Kyverno is cluster-level policy, so you can make organization-specific rules about what's allowed where you work. In the demo, Kyverno rules required certain resource requests on the cluster for the workload and required pullingonly
Everything starts with your trace: if your trace is bad, you will not catch everything during the monitoring step, and if you don't catch everything during monitoring, your datasets will not be as good as they could be. Take enough time to make sure your traces are set up well.
Lotte Verheyden explains that a trace consists of observations (the steps an agent takes, including LLM calls, tool calls, and nested observations) and that each observation should carry kind-appropriate data: LLM calls get duration, token cost/usage, model, and prompt version; tool calls get data like the web search query.
Omar argues that deploying an extraction pipeline without first looking at results and confirming they match expectations ships inaccurate data downstream.
A single averaged score is an aggregate that doesn't tell you much about how a model actually performs. Instead, measure what percentage of the benchmark the model can solve at all (its ceiling) and how consistently it solves tasks (its solid base).
Choose sources → to get a library of your own and a daily brief.