35,595 results · Most relevant
A connected agent can create a conversational space as an owner and invite other agents (such as a Codex) and the human user; agents in the shared space can start working on engineering tasks together, and a terminal Claude session can talk to a Codex SDK of the same user — because the platform is global, the specific agent or SDK combination does not matter, and agents can talk to your agent and so on.
MCP means stateless calls so you cannot go back to the agent you talked to; A2A is one-way client-server unless you implement both client and server on the same side, and is still in draft with discovery missing; chaining REST API calls between agents meets timeouts.
Philipp Schmid describes the Agents API: you create a base agent defining the underlying brain, the instruction, and the environment (raw environment with sources, or an existing environment). You can use an agent to create its own environment (e.g., install the GitHub CLI, add skills, do sanity checks), get back an environment ID, and use that ID to create a new agent that starts from the pre-loaded, pre-configured environment every time it's called. You can share agents built on pre-configured environments with your users or customers without writing any Terraform, Kubernetes, microservices, or Firecracker infrastructure.
Philipp Schmid explains that when a request is sent, the sandbox starts and loads all files, then the agent loop runs completely on the server. When building agents normally, you need to manage function calling on your client: pass the function call, run it somewhere, and send back the function result. With managed agents, function calling is just a single API call and everything runs inside the remote sandbox. You can also connect remote MCP servers and run local MCP servers inside the managed agent environment.
Philipp Schmid explains that Google moved away from the user-model turn principle to a synchronous timeline of steps, where every action or generation is its own type. With previous APIs you had to use the user turn to return function output, which felt weird because the output comes from the environment, not the user. The step-based timeline makes it easy to extend to new features and capabilities while staying simple, because you define what the agent has done; when building a function-calling agent you return a function result rather than a role user with content.
Conor Hale walks through how AutoClusters, Crusoe's system for automatically detecting and replacing failed GPU nodes, handles a critical hardware error: the user is notified with no action required; the Slurm operator sets the failed node down and cancels its running jobs; the job is automatically re-queued; the Kubernetes node is verified to have no label disabling automatic replacement, then cordoned and drained; the unhealthy node is replaced with a new healthy node from spare capacity; and a record of the alert and remediation is logged for the user's reference.
deterministic
The most promising near-term direction in neuromorphic computing is the commingling of memory and compute, done purely digitally, where a bunch of startups are working. One approach is combining SRAM and logic. D-Matrix is a startup that has done good work here, including a strong Hot Chips presentation; its innovation is essentially co-packaging: bringing SRAM very close to compute in the memory hierarchy on the decode side to address the decode ceiling. IBM has also done work in this area. D-Matrix feels like a makeable-now digital memory-compute company: it works, it can be manufactured, and the market can take it up. However, co-packaging SRAM close to compute increases the surface area of the packaging, which means fewer servers fit in the same amount of data center space, and the do[
When the campaign coordinator spawned the vetter, things started to unravel: the vetter disqualified almost every single prospect, including sites with clear consistent traffic growth. The cause was a bug in the traffic slope field — the enrichment data showed negative slopes for prospects with clear five-year growth, causing wrongful disqualification. The speaker verified against the raw data before trusting the agent's output.
Gabriel Chua frames the next section: Codex is well suited to complex refactors and long-running tasks, and he shares tips for working with it on those, including kicking off long-running tasks the night before and letting them run while you do other things, and running them on a remote instance so they continue in the background.
described
Applying the why-why-why method to the facial recognition request reveals the underlying problem: check-in is slow. The core job of the app is getting people into the room and knowing who came in, and the job statement has nothing to do with facial recognition — understanding it informs what to build.
Laurie Voss explains that online evals take the evaluators you wrote (ticker check, faithfulness, actionability) and run them automatically on incoming production traces — the same evals running on new data.
The source describes a case where a voice agent processed a refund for order 40 instead of order 14, and the transcript looked fine but the call wasn't, making it the canonical example of transcript-vs-audio failure.
Implementing observability in an OpenAI Agents SDK application is as simple as turning it on, because the SDK is already instrumented with OpenInference. The agent was told to send the traces it was already generating to the Arize endpoint with the API key, and after a restart and a query, traces were flowing into the Arize project with no code written.
Commercial context: The creator presents this as their own offering and directs viewers to get it.
Even though evals compress thousands of traces into eval scores, at 2026 scale you get so many evals running that you cannot stay on top of them as a human by yourself. The proposed solution is to have an agent read eval failures en masse to detect signals and patterns — for example, identifying that 100 of 1,000 failed requests are the same failure — and fix that pattern.
When asked for bomb-building instructions, the demo agent said it couldn't help but then recommended bomb-related toys — a harmful-query failure. The correct behavior is to ignore such queries entirely rather than trying to be helpful, and a basic safety eval ensuring the agent never gives bomb-building instructions should have existed from the beginning.
The speaker asked the agent to use the skills he gave it to pull down his traces from Arize AX directly; the agent has the API key and the endpoint. A default off-the-shelf coding agent would not know how to pull and analyze traces — the installed skills are what give it that knowledge.
Dr Ghayas Issa advises that the key factor for improving durability of response — hopefully cure — in relapsed/refractory disease treated with menin inhibitors is consolidation with a stem cell transplant.
Consequential creator advice requires independent verification before Today can promote it.
In the live demo, the scenario tested was: 'I purchased headphones 20 days ago, I want to return them. Can I?' The correct answer was that you cannot return them (return window is 14 days), and the test expected the answer to contain 'cannot'. The speaker wrote a unit test for a TypeScript function add(num1, num2) that should return the sum, and ran it with npx vitest. The test iterated over each candidate answer with answers.forEach and expected each answer to contain 'cannot'. The scenario answer 'yes, you can return them for free' failed the test, while 'no, you cannot return them' passed. The demo answers were generated by an LLM, which is why the test was non-deterministic. Fuzzy matching on a keyword like 'cannot' is non-deterministic and breaks: an LLM-generated answer like 'you
The full eval pipeline journey: start with a unit test, make it fuzzy, add a judge, train the judge, put it in production, gate on agreement, keep it living by skimming data and adding it to the data set, and even discover policy automatically. The speaker ran a naive job five times with a pairwise prompt asking which reply is helpful, and the results were a mixed bag with all wrong answers. When the policy is included in the prompt and the eval is run five times, the results are suddenly correct. The speaker built a more aesthetic demo of the eval system as a running application (npm run dev on port 5173).
Even after giving the model the right context, a low-quality model may still not behave — at that point you must consider a better model. A very low-quality model produces extra problems like case-mixed responses, signaling you're under the floor of quality. Once you've maxed out context and policy work and the model still misbehaves, that's the right time to switch to a higher-quality model — but you don't have to go crazy. Switch to GPT-4.0 Mini as a higher-quality model upgrade for eval use cases, since it is practically free and token usage is low. GPT-4.0 Mini produces consistent casing between pass and fail responses, making it a significant upgrade at a good price. When you bump the model to a higher-quality one without changing anything else, the eval agreement improves
Choose sources → to get a library of your own and a daily brief.