Anthropic launches Claude Tag, a channel-aware AI teammate for Slack

Anthropic launched Claude Tag, transforming its Slack integration from a reactive chatbot into a channel-aware AI teammate with shared context, proactive updates, and scoped administrative controls. Alibaba’s Qwen team released AgentWorld, language world models (35B and 397B parameters) trained on 10M+ real-world interaction trajectories that substantially outperform frontier models on agentic benchmarks. A convergence of ArXiv papers on agent reliability – formalizing multi-agent memory failure modes, Bayesian orchestration control, and security vulnerabilities in offensive-security agents – signals that the research community is shifting from building agents to hardening them.

Developer Tools #

Introducing Claude Tag #

Anthropic / TechCrunch / The Register

Anthropic launched Claude Tag, a new Slack integration that replaces the previous Claude in Slack app with a channel-aware AI teammate. Unlike the old reactive chatbot, Claude Tag maintains shared context across entire channels, learns from ongoing conversations, and proactively surfaces updates it thinks the team needs. The feature supports multiplayer collaboration where all team members see Claude’s work in progress, and offers administrators channel-scoped access controls, spending limits, and full audit logs. The strategic play is clear: by embedding Claude into the place where organizational knowledge already lives, Anthropic captures the enterprise context that makes switching costs high and competitive moats deep.

NVIDIA Agent Toolkit: Open Models, Tools, Skills, and Secure Runtime for AI Agents #

NVIDIA Blog

NVIDIA released the Agent Toolkit, an open foundation for building domain-specific enterprise AI agents comprising three components: Nemotron open models for customization, NemoClaw blueprints for safer agent behavior with integrated tools, and OpenShell runtime for secure execution. The toolkit is already deployed across life sciences, healthcare, cybersecurity, and chip design, targeting the gap between generic chat interfaces and the specialized reasoning-plus-action workflows enterprises actually need. For teams evaluating agent frameworks, the combination of open models with a security-focused runtime addresses the two biggest enterprise objections to agent adoption: vendor lock-in and uncontrolled tool execution.

Build real agentic apps using CUGA: two dozen working examples on a lightweight harness #

Hugging Face Blog / IBM Research

IBM released CUGA (Configurable Generalist Agent), an open-source agent harness that handles orchestration, planning, execution, tool invocation, and reflection through pre-assembled components. The framework ships with 24 working example applications spanning productivity tools, research workflows, RAG-based document analysis, and multi-agent systems with specialized delegates – each distilled to a tool list and system prompt. CUGA is provider-agnostic, supporting OpenAI, Anthropic, watsonx, and local Ollama deployments via MCP servers for shared capabilities, which makes it a practical starting point for teams that want agentic patterns without committing to a single vendor’s framework.

Amazon Bedrock AgentCore: Multi-Tenant Patterns and Protein Research Copilot #

AWS Machine Learning Blog

AWS published two AgentCore reference architectures: a multi-tenant agent pattern demonstrating pool-model multi-tenancy for healthcare AI agents serving multiple clinics, and a protein research copilot combining natural language query parsing with vector similarity search over protein embeddings. The multi-tenancy pattern is the more broadly applicable contribution: it shows how to share agent infrastructure across organizational boundaries while maintaining tenant isolation, a requirement that most agent frameworks punt on entirely. The protein copilot demonstrates the integration pattern – structured parameter extraction, domain-specific embeddings, AI-generated summaries – that applies to any specialized research domain.

Research & Papers #

Qwen-AgentWorld: Language World Models for General Agents #

arxiv:cs.AI / Hacker News (117 points)

The Qwen team released AgentWorld, a pair of language world models (35B and 397B parameters) that simulate agentic environments across seven domains, trained on over 10 million real-world interaction trajectories using a three-stage pipeline of pretraining, supervised fine-tuning, and reinforcement learning with hybrid rewards. The models substantially outperform existing frontier models on AgentWorldBench, derived from real-world interactions across nine established benchmarks. The practical value is twofold: the models serve as decoupled environment simulators for RL training (eliminating the need for expensive real-environment rollouts) and as foundation models that improve downstream agent performance when used for warm-up training. Language world models that can predict environment dynamics from observations and actions represent the kind of planning substrate that current agent architectures lack.

OpenThoughts-Agent: Data Recipes for Agentic Models #

arxiv:cs.AI

This paper addresses the gap between single-benchmark agentic training (like SWE-Smith for coding) and broadly capable agents by releasing a fully open data curation pipeline for training models that generalize across diverse agentic tasks. Existing open efforts target individual benchmarks, leaving the question of cross-task generalization unanswered. OpenThoughts-Agent provides the data recipes – curation strategy, mixing ratios, and quality filtering – that connect task-specific training data to broad agentic capability, making it a practical guide for teams that want to fine-tune their own agent models rather than relying on proprietary ones.

Governed Shared Memory for Multi-Agent LLM Systems #

arxiv:cs.AI

This paper formalizes the “fleet-memory problem” and identifies four foundational failure modes in multi-agent systems: unauthorized leakage, stale propagation, contradiction persistence, and provenance collapse. The authors define explicit systems-level primitives – scoped retrieval, temporal supersession, provenance tracking, and policy-governed memory propagation – to address each. For teams building multi-agent architectures, the contribution is a formal vocabulary for failures that are currently discovered ad hoc in production: your agents share stale context, contradict each other, or leak information across trust boundaries, and now there are named primitives for preventing each.

Bayesian Control for Coding Agents #

arxiv:cs.AI

This paper reframes agent orchestration as cost-sensitive sequential hypothesis testing: a Bayesian controller maintains a belief over candidate correctness and dynamically decides whether to gather more evidence (cheap diagnostics), refine the candidate, or invoke expensive verifiers. Current orchestrators typically use fixed rules and ignore uncertainty, which means they either over-verify (wasting expensive compute) or under-verify (shipping wrong answers). For anyone building coding agents or similar tool-use pipelines, the formulation provides a principled alternative to the heuristic “run linter, then maybe run tests” orchestration that most systems currently use.

Maestro Order: A Model-Agnostic Orchestration Harness #

arxiv:cs.AI

Maestro Order turns unreliable model solvers into reliable problem-solving systems by composing them through four structural primitives: decompose, ensemble, verify, and iterate. The key claim is that a single model forward pass is “right often enough to be useful and wrong often enough to be dangerous,” and the solution is not a better model but a better harness. The primitives are model-agnostic, meaning the same orchestration structure works regardless of which LLM sits underneath – a property that matters as teams swap between models and the orchestration logic should not need to change.

Detecting AI Coding Agents in Open Source: A Census of 180 Million Repositories #

arxiv:cs.AI / Hugging Face Daily Papers

A multi-layered detection framework scanned 180M+ Git repositories across World of Code, integrating configuration-file scanning, commit-message analysis, author-identity matching, and bot-signature lookup to classify AI coding agent traces into four behavioral types. The headline finding: no single detection method captures more than a fraction of AI-generated activity, and multi-method fusion is required for accurate measurement. For teams concerned about supply chain provenance or trying to measure AI adoption in their codebases, this establishes the methodological baseline – and reveals that AI-generated code is already more prevalent in open source than any single signal would suggest.

Security #

Red-Teaming the Agentic Red-Team #

arxiv:cs.AI / Hugging Face Daily Papers

The first in-depth security analysis of widely used agentic systems for offensive security operations reveals that most share common design flaws that make them vulnerable to the same classes of attacks they are designed to execute. The paper finds systematic weaknesses across the agent frameworks used for penetration testing and security auditing – the tools the security community increasingly depends on are themselves insecure. The irony is pointed: organizations deploying agents for security testing need to red-team the red-teamers, and the attack surface grows with each layer of agent autonomy.

RIFT-Bench: Dynamic Red-teaming for Agentic AI Systems #

arxiv:cs.AI

RIFT-Bench introduces a graph representation-driven methodology for dynamic red-teaming that enables unified comparison across heterogeneous agentic systems – addressing the gap where existing security evaluations are tied to specific implementations or domains. The benchmark exposes attack vectors beyond traditional LLM vulnerabilities that emerge specifically from autonomous decision-making in agent architectures. Paired with the Red-Teaming the Agentic Red-Team paper above, the research community now has both a diagnostic framework (RIFT-Bench) and an empirical audit (Red-Team analysis) for agentic system security.

Vulnerability reports are not special anymore #

Filippo Valsorda / Hacker News (290 points)

Filippo Valsorda argues that LLMs have commoditized vulnerability discovery to the point where security researchers’ traditional advantage – scarce expertise plus coordinated disclosure – has evaporated. His core claim: “LLMs are as good as almost any security researcher, and anyone can run them,” meaning attackers have the same capabilities and the confidentiality window of coordinated disclosure no longer provides meaningful protection. The practical recommendation for maintainers is to shift from managing researcher relationships to running automated LLM analysis in CI pipelines and prioritizing rapid remediation – a workflow that treats vulnerability discovery as a commodity input rather than a scarce expert service.

Infrastructure #

NVIDIA and AWS Collaborate to Bring AI to Production at Scale #

NVIDIA Blog

NVIDIA and AWS announced three production infrastructure advances: Amazon EC2 G7 instances powered by NVIDIA RTX PRO 4500 Blackwell GPUs delivering up to 4.6x AI inference performance over G6 instances; GPU-accelerated vector search in Amazon OpenSearch Serverless via NVIDIA’s cuVS library achieving 10x faster indexing at one quarter the cost of CPU-only approaches; and AWS achieving NVIDIA Exemplar Cloud status for GB300 training workloads. The vector search integration is the most immediately useful: enterprise RAG applications currently bottleneck on index build times and per-query latency, and a 10x improvement at lower cost directly changes the economics of production retrieval pipelines.

Serving DeepSeek-V4 on GB300 with SGLang: 5x Higher Throughput Since Day-0 #

PyTorch Blog

SGLang achieved a 5x throughput improvement for serving DeepSeek-V4 on NVIDIA GB300 hardware, reaching approximately 11,200 tokens/sec/GPU at 50 tok/s/user interactivity – up from 2,200 tok/s/GPU at Day-0 launch in April 2026. The gains came from coordinated kernel optimizations (MHC fusion, KV Compression V2, W4A4 MegaMoE) and runtime bug fixes rather than architectural changes, demonstrating that serving-side engineering can deliver model-generation-scale improvements. On Blackwell Ultra aggregated configurations, throughput improved 2.91x at 30 tok/s/user with 6x peak non-MTP throughput, confirming that the optimization techniques transfer across NVIDIA’s current GPU lineup.

Oracle’s 21,000 layoffs help drive its debt-fueled AI investments #

Ars Technica

Oracle is cutting 21,000 positions while spending billions on data center infrastructure to support AI workloads, funding the build-out through significant debt. The pattern – cutting headcount to finance AI infrastructure – continues the trend tracked in TechCrunch’s running list of AI-attributed layoffs and underscores that the largest enterprise technology companies are treating AI compute capacity as a survival investment worth financing with balance-sheet leverage.

Funding & Business #

MoEngage acquires Aampe to bet marketing’s future on millions of AI agents #

TechCrunch

Indian marketing platform MoEngage acquired San Francisco-based Aampe in an all-cash deal valued at tens of millions of dollars, gaining technology that assigns a dedicated AI agent to each individual customer rather than grouping users into audience segments. The approach represents a structural shift in marketing automation: instead of rules-based campaigns targeting demographic cohorts, autonomous agents make per-customer decisions about targeting, message selection, and send timing. MoEngage plans to use this against Salesforce and Adobe in the enterprise marketing space, betting that personalization at agent-per-customer granularity will be the competitive differentiator.

Open Source #

Unlimited-OCR: One-shot Long-horizon OCR #

Baidu / Lobsters

Baidu released Unlimited-OCR, an open-source document parsing model that processes lengthy multi-page documents in a single pass with context windows up to 32,768 tokens, supporting both individual images and PDF files. The model handles variable image sizes through two configuration modes and provides streaming inference through both Hugging Face Transformers and SGLang backends. For document processing pipelines that currently chunk, OCR, and reassemble, a single-pass approach eliminates the page-boundary artifacts and context fragmentation that degrade extraction quality on long documents.

Regulatory & Policy #

Helping build shared standards for advanced AI #

OpenAI News

OpenAI announced its involvement in building shared standards for advanced AI through the Appia Foundation, supporting evaluation frameworks, safety practices, and global cooperation on AI governance. The article was not accessible for detailed analysis (HTTP 403), but the initiative signals OpenAI’s participation in multilateral standards-setting at a time when unilateral national approaches – including the recent US executive order on AI innovation and security and the bipartisan Great American AI Act discussion draft – are proliferating. Whether voluntary industry standards can keep pace with legislative momentum remains the open question.

Threads to Watch #

Agent security research is getting systematic treatment. Three papers in a single day’s ArXiv batch address agentic system security from complementary angles: RIFT-Bench provides a unified red-teaming benchmark, Red-Teaming the Agentic Red-Team audits existing offensive-security agents, and Governed Shared Memory formalizes memory-layer failure modes. Combined with Valsorda’s argument that LLMs have commoditized vulnerability discovery, the security landscape for agent builders is shifting from “find bugs faster” to “your agent infrastructure is itself an attack surface.”

Enterprise Slack is becoming the AI control plane. Anthropic’s Claude Tag launch – with channel-scoped context, proactive updates, spending limits, and audit logs – positions Slack as the surface where AI agents accumulate organizational knowledge and earn trust through transparency. The feature set reads less like a chatbot upgrade and more like enterprise middleware: access controls, cost governance, and observability are the requirements that separate toy integrations from production deployments.

The agent infrastructure stack is crystallizing into named layers. NVIDIA’s Agent Toolkit (models + tools + secure runtime), IBM’s CUGA (orchestration + planning + tool invocation), Maestro Order (decompose + ensemble + verify + iterate), and AWS AgentCore (multi-tenancy + domain-specific patterns) all decompose the “agent” concept into explicit architectural layers. When four independent teams converge on similar decompositions in the same week, the pattern is stabilizing – and teams that treat agents as monolithic black boxes will increasingly find themselves at an architectural disadvantage.

Sources Unavailable Today #

These sources could not be fetched today. Links point to their homepages so you can check them directly.

• Weights & Biases: Fully Connected – scrape: content not extractable