Claude only receives redacted versions of sensitive documents via the MCP
When using Claude with an MCP that processes sensitive documents, Claude only gets the redacted version of the document, not the full document.
42,607 results · Most relevant
When using Claude with an MCP that processes sensitive documents, Claude only gets the redacted version of the document, not the full document.
Running 'WoW App Create' names the app, scans the machine for Git, GitHub login, Node, and secrets management, creates a repo in the enterprise GitHub account from a predefined template, and clones in an example application for Claude Code or Codex to build from.
WorkOS created an internal CLI (WoW) that lets anyone at the company build an app with Claude Code or Codex and deploy it live to the entire company without asking engineers for deployment help or account provisioning.
In the early days of scaling the lab, huge bottlenecks were imposed just by operating machinery. Technicians and scientists would look for particular morphology to see what was actually being made and whether it was consistent with intentions. As the lab scaled up, human operation hit bottlenecks where it just wasn't keeping up. A simple programmatic approach to capturing SEM data — take the field of view, capture, zoom in, capture — produced data that was not all that useful; it was 'a little too dumb.' It became pertinent to build AI systems directly onto the machines to control them, giving the systems full context of the experiment's intent.
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.
Choose sources → to get a library of your own and a daily brief.