📡 Industry Signals
What's happening?
79% of enterprises run AI agents in production — the next fight is vendor lock-in 🔗
The enterprise AI conversation has moved past adoption. A 2026 industry survey finds 79% of enterprises are already running AI agents in production, and 100% of surveyed organisations plan to expand agent deployments this year. Every major Artificial Intelligence (AI) vendor — Anthropic, OpenAI, Google, Microsoft, and Amazon — is now forming formal partnerships with system integrators and consulting firms to help clients actually deploy what they have bought. The volume question has collapsed. The practitioner question has shifted from "do we pilot?" to "how do we avoid building on foundations we cannot replace?"
The capital flows follow the same pattern. Startups that instrument AI systems — observability, governance, agent orchestration — are winning growth-stage rounds when they can tie their product to a measurable business control point. Nexus raised $4.3 million to scale enterprise agent deployment, NeuBird closed $19.3 million for autonomous DevOps and site reliability engineering (SRE) operations, and Auctor took a $20 million Series A led by Sequoia to build an "AI system of action" for enterprise software implementation. Underneath the adoption surge, every buyer is now also asking a second question: which layer of this stack is portable, and which becomes permanent.
Why it mattersAdoption is the baseline now — exit strategy is the differentiator. Chief Technology Officers (CTOs) should audit which orchestration, memory, and tool-calling layers sit on proprietary vendor stacks versus open standards like the Model Context Protocol (MCP) or Anthropic's Agent Skills format. Quantify the switching cost before the next procurement cycle. Portability is the 2026 budget line nobody is expensing yet.
Read source →
Claw Code's 72K GitHub stars: the coding-agent layer is commoditising fast 🔗
Claw Code — a vendor-neutral open-source coding agent framework — drew 72,000 GitHub stars in its first days of public release, a pace that outstrips every prior coding-agent debut including Cursor, Aider, and the early Claude Code beta. The framework runs against any underlying large language model (LLM) backend — Anthropic, OpenAI, Google, local Ollama — with no vendor lock-in on the orchestration layer. The speed of adoption is the data point, not the feature set: when 72K developers star a project inside a week, the signal is demand, not novelty.
The consequence is structural. The coding agent layer — the part that turns a model call into a planned, tested, committed change — is consolidating around open frameworks. Meanwhile the model layer underneath continues to fragment as Anthropic, OpenAI, Google, xAI, and Meta each ship capability updates weekly. Put together, developers get to swap models without rewriting their workflow. Model vendors get to compete on capability without capturing the workflow itself. The middle layer is where the commodity pressure lands first.
What it signalsThe portable layer for AI coding is production-ready. Chief Information Officers (CIOs) evaluating proprietary suites with per-seat lock-in should reassess the premium: if the same workflow runs across any model, the only defensible edge is first-class integration with internal tooling. Benchmark an open framework against your incumbent on three real tasks before the next renewal.
Read source →
Equinix Fabric Intelligence reframes AI inference routing as a networking problem 🔗
Equinix, the world's largest colocation operator, launched Fabric Intelligence on April 15. The product bundles private, high-speed interconnect between enterprise data, vector databases, and the major foundation model endpoints (Amazon Web Services (AWS) Bedrock, Microsoft Azure AI Foundry, Google Vertex, Anthropic, OpenAI) into a single networking contract. The pitch is specific: as enterprises move from pilot to production inference, the binding constraint has shifted from model quality to round-trip latency from application code to the model endpoint. Fabric Intelligence reframes that constraint as a networking problem, selling dedicated interconnects between colocated enterprise infrastructure and the hyperscaler AI fabric — with deterministic latency contracts attached. It is the first time a major colocation vendor has treated AI model access as a distinct network service class.
What it signalsWhen Equinix — a $30 billion colocation business — reorganises around AI inference, the bet is that inference traffic will justify dedicated interconnect. Chief Technology Officers (CTOs) running production inference workloads should benchmark public-internet latency to model endpoints against the private fabric — at volume, the cost difference often inverts. Watch whether Digital Realty and CoreSite ship similar AI-native networking within 90 days; that confirms the pattern is industry-wide, not a single-vendor bet.
Read source →
🧠 Models & Tools
What's new?
Block donates Goose and 70+ MCP extensions to the new Agentic AI Foundation (AAIF) 🔗
The on-device agent layer just got a governance body that none of its backers individually control. Block has donated Goose, the Model Context Protocol (MCP) specification, and the AGENTS.md contributor standard to the new Agentic AI Foundation (AAIF) under the Linux Foundation — a structure underwritten by AWS, Anthropic, Google, Microsoft, and OpenAI. Goose itself is a local-first AI agent that runs on macOS, Linux, and Windows as a native desktop app with a full command-line interface (CLI), works across 15+ model providers, and ships with 70+ MCP extensions.
What it enablesTeams worried about vendor lock-in finally have a credibly neutral agent platform with industry-backed governance. And because Goose is local-first — data never leaves the machine by default — it clears the compliance bar that blocks cloud-routed agents in regulated sectors (healthcare, legal, finance). Pilot Goose against an equivalent cloud-agent workflow and measure the latency and data-residency delta before scaling.
Read source →
Superpowers: run your coding agents as a team, not a single assistant 🔗
Superpowers, released April 16 by developer "obra", is a methodology framework for coding agents built around composable skills. Instead of prompting a single agent with a long instruction, Superpowers breaks a software task into discrete skills — planning, testing, review, refactoring, deployment — each encoded as a reusable module that any underlying coding agent can invoke. The design sits one level above tools like Claw Code or Claude Code: it does not replace them, it orchestrates what they do in sequence and under what guardrails. The framework targets the reliability gap that has become the practitioner's main complaint about AI coding — that the same agent produces high-quality output on one task and low-quality output on the next because nothing enforces a consistent process. Superpowers makes the process the artefact.
Try thisIf your team currently relies on AI coding agents without a shared skill library, Superpowers is worth evaluating as the governance layer. Encode your team's review checklist, test coverage threshold, and commit message format as skills once; every agent run then executes against the same standards whether or not a senior engineer is reviewing. The payoff is highest in regulated codebases where consistency of process matters more than speed of any single task.
Read source →
🚀 Applications
What's working?
Auctor raises $20M from Sequoia to automate the $300B enterprise software implementation layer 🔗
Auctor closed a $20 million Series A led by Sequoia Capital to build an "AI system of action" for the enterprise software implementation market — the services layer that large system integrators have built $300 billion annual businesses around. The pitch is simple: a mid-size enterprise resource planning (ERP), customer relationship management (CRM), or human resources (HR) system rollout that historically took 18 months of human consulting effort is compressed into AI-orchestrated configuration, integration, and testing. Auctor's agents read existing process documentation, generate integration mappings, configure target systems, and run validation suites — replacing the largest line item of most enterprise software deployments: professional services. The company claims early deployments have cut implementation timelines by 60–70% with a fraction of the billable consulting hours.
What it provesThe enterprise AI thesis has shifted from "replace the software" to "replace the implementation around the software". That is a much larger addressable market, and it hits vendors (Accenture, Deloitte, Infosys, Tata Consultancy Services) whose business models depend on long human-hours implementation cycles. Chief Information Officers (CIOs) planning any major enterprise software rollout in the next 12 months should add one evaluation line: the all-in cost and timeline with an AI implementation partner versus the incumbent systems integrator quote.
Read source →
Firefly AI Assistant moves Adobe from generation to agentic work across Photoshop, Premiere, and Illustrator 🔗
Adobe announced the Firefly AI Assistant on April 15, now in public beta. The assistant operates across Photoshop, Premiere Pro, Lightroom, Illustrator, Adobe Express, and the Firefly app itself — executing multi-step tasks inside those applications rather than just generating assets to paste in. A user can ask the assistant to "remove the background in this photo, match it to the brand palette in my library, export a web-ready version, and place it in the hero slot of this Premiere timeline" — and the assistant drives the actual application interface (UI) to complete the work. This is the feature that turns Creative Cloud from a suite of generation tools into an agentic creative environment — closer to what Claude with computer use or OpenAI's Operator demonstrated at the model level, but built directly into the application suite that professional creators already use daily.
Try thisIf you already have a Creative Cloud subscription, join the Firefly AI Assistant beta through the Firefly app. The highest-value test is a cross-app workflow — e.g., generate a Firefly image, retouch it in Photoshop, colour-grade in Lightroom, and drop it into a Premiere sequence — driven end-to-end by the assistant. The useful comparison point is the same task performed manually across the four applications; the time delta is the purchasing argument.
Read source →
NeuBird closes $19.3M as AI agents move into the on-call rotation 🔗
NeuBird closed a $19.3 million oversubscribed funding round led by Xora Innovation to scale agentic AI across enterprise DevOps, site reliability engineering (SRE), and IT operations teams. The product targets the highest-cost, highest-turnover function in most engineering organisations: the on-call engineer who investigates alerts, correlates logs across services, identifies root causes, and either remediates automatically or escalates with context. NeuBird's agents run that loop autonomously — ingest an alert, query metrics and logs, form a hypothesis, test it, apply a known-safe remediation or page a human with a structured summary. For most production incidents where the root cause is a known pattern (expired certificates, configuration drift, upstream dependency failures), the agent closes the loop without human involvement. For novel incidents, the human is paged with a pre-investigated diagnosis instead of a raw alert.
What it enablesThe real AI-in-DevOps payoff is retention, not engineer-hours — compressing the on-call burden is what keeps senior infrastructure engineers from quitting. For heads of infrastructure and SRE, the metric that matters is mean time to resolution (MTTR) on Severity-3 (Sev-3) incidents specifically — the ones on-call humans hate and agentic tools resolve cleanly. Track Sev-3 MTTR over a three-month pilot before broader rollout.
Read source →
💡 Term of the Day
What does it actually mean?
Model Context Protocol (MCP) 🔗
Agent Infrastructure · Open Standard
The Model Context Protocol (MCP) is an open specification — originally published by Anthropic and now stewarded by the Linux Foundation's Agentic AI Foundation (AAIF) — that defines how AI agents discover, authenticate to, and call external tools, data sources, and services. The design problem MCP solves is specific: before MCP, every AI agent framework invented its own way to describe a tool and every tool vendor invented its own way to describe its capabilities, which meant that connecting a new tool to a new agent required writing a custom adapter. MCP standardises three things: how a tool server advertises what it can do (schema discovery), how an agent calls that tool with structured arguments and receives a structured response (transport and typing), and how authentication and authorisation flow between them (OAuth 2.0-based). Because the spec is open and governed neutrally, tool vendors write one MCP server and it works with every compliant agent; agent developers write one MCP client and it works with every compliant tool. The ecosystem now includes thousands of tool servers — covering databases, document stores, development environments, business systems, and operating system interfaces — and every major agent framework (Goose, Claw Code, Claude Desktop, ChatGPT's tool-use mode, Gemini's extension layer) either supports MCP natively or ships an MCP client.
Why Practitioners Misread This
The most common misreading is treating MCP as a vendor-specific protocol tied to Anthropic because Claude Desktop was the first major client and the specification originated there. The December 2025 contribution to the Agentic AI Foundation moved MCP out of single-vendor governance, with AWS, Google, Microsoft, and OpenAI now co-funding the foundation that maintains it. The second misreading is assuming MCP competes with agent frameworks like Goose, Claw Code, or Superpowers — it does not. MCP is the wiring between an agent and a tool; frameworks are the wiring around a set of agents. A production stack uses both. The third misreading is treating MCP adoption as a binary capability decision. The real question is surface area: how many of the tools, systems, and data sources your agents need to reach already speak MCP, and what is the custom-integration cost for the ones that do not. For most enterprise teams, the answer now skews MCP-heavy enough that picking non-MCP agent tooling creates integration debt within twelve months.
⚠️ Safety & Policy
What's being governed?
DOJ's AI Litigation Task Force opens the federal-state preemption fight over frontier AI 🔗
The Department of Justice (DOJ) established an AI Litigation Task Force in January 2026 with the explicit mandate to challenge state AI laws it deems unconstitutional — specifically, statutes the task force believes unlawfully regulate interstate commerce or are preempted by existing federal regulation. In the first quarter of 2026, task force filings have targeted provisions in California's S.B. 53 and New York's RAISE Act, arguing that state-level frontier model rules create a fragmented compliance environment that only Congress is empowered to set. State attorneys general in both jurisdictions have pushed back, arguing the federal government has not yet acted and states therefore have the police-power authority to regulate AI harms within their borders. The underlying tension is procedural, not ideological: both sides agree frontier model governance is needed; they disagree on which level of government holds the pen.
What it signalsState AI laws remain in force until courts rule otherwise — typically 12–24 months. Chief Legal Officers (CLOs) and compliance heads at frontier AI developers should keep complying with the strictest applicable state rules and track task force filings weekly. The litigation signal to watch: whether DOJ consolidates challenges into a single circuit. That would pull federal preemption forward from the consensus mid-2027 estimate into the current administration's timeline.
Read source →
New York's RAISE Act: 72 hours to report critical AI safety incidents 🔗
The Responsible AI Safety and Education Act (RAISE Act) — sponsored by New York Senator Andrew Gounardes — took effect on March 19, 2026. The law requires developers of large frontier AI models operating in New York State to: publish detailed safety plans covering pre-deployment evaluation, risk mitigation, and incident response; report critical safety incidents to the state within 72 hours of discovery; and submit to annual compliance reporting. Enforcement sits with a new, dedicated office inside the New York Department of Financial Services (DFS) — a non-trivial choice, because DFS already regulates the banks, insurers, and capital market participants that are the heaviest institutional deployers of AI models in the state. The office will publish annual public reports on frontier AI developer compliance. As of April, the Transparency Coalition's tracker shows 78 chatbot and AI disclosure bills alive in 27 U.S. states — RAISE is the most substantive of those already enacted, and New York DFS enforcement infrastructure is the reason.
The compliance angleThe 72-hour reporting window is the operative detail. Runbooks built for post-hoc public disclosure will not meet it. Chief Information Security Officers (CISOs) and AI governance leads at frontier developers with material New York exposure should stand up an internal reporting path that triggers within hours — not days — of a qualifying incident. The second question this quarter: which of your existing incident classes already fall inside the DFS "critical" boundary once guidance drops.
Read source →
📄 Research Papers
What's being researched?
Spatial Atlas: solve sub-problems deterministically, ask the model only about judgment 🔗
Spatial Atlas introduces compute-grounded reasoning (CGR) — a design pattern for research agents in which every sub-problem that can be solved deterministically (counting, measuring distances, running a query, executing a calculation) is resolved by code before the language model is asked to reason. The paper benchmarks the approach on two demanding test suites: FieldWorkArena, a multimodal spatial question-answering benchmark covering factory, warehouse, and retail environments, and MLE-Bench, 75 Kaggle machine learning competitions requiring end-to-end machine learning engineering. The Spatial Atlas agent — implemented as a single Agent-to-Agent (A2A) server — outperforms leading baseline research agents on both, with the margin widest on problems where spatial arithmetic or exact counts matter. The paper's broader thesis: the failure mode of current research agents is not insufficient reasoning capacity; it is asking models to reason about quantities the model should have just computed.
If this holdsFor any agent workflow where sub-problems have deterministic answers — look up, count, measure, calculate, query — do those steps in code and let the model handle only judgment. Teams building research agents or spatial reasoning systems should audit their prompts for quantities the model is being asked to estimate when a tool call would compute them exactly. The Spatial Atlas accuracy gains suggest this is the highest-leverage architectural change available to most agent teams today.
Read source →
Three levers that actually improve agent performance: post-training, memory, and skills 🔗
This survey consolidates the research literature on how agentic AI systems improve after initial model training — and argues that three distinct adaptation mechanisms are each responsible for different kinds of gains: post-training methods (reinforcement learning with verifiable rewards, as popularised by DeepSeek's approach and extended by OpenClaw), persistent memory systems that let an agent carry context across sessions, and reusable skills that encode how to approach a class of task. The survey's practical contribution is delineating which mechanism to reach for in which situation:
- Post-training — when the agent needs a new reasoning capability its base model lacks.
- Memory — when the agent needs to accumulate knowledge about a specific user, project, or domain over time.
- Skills — when the agent needs to follow a repeatable process with consistent quality.
The three mechanisms are complementary, not substitutable; most production-grade agents in 2026 end up using all three.
What it provesTeams treating agent performance as one dial — "use a bigger model" — are under-investing in the two cheapest levers. Memory and curated skills compound without changing the model beneath. For engineering leads running agents in production: which of the three mechanisms is doing the most work in your stack, and which is the most neglected? The answer tells you where the next quarter of investment has the highest marginal return.
Read source →