Archive 23.10.2026

Page 3 of 56
1 2 3 4 5 … 56

A tiny defect in a crystal reveals a big quantum surprise

Researchers have solved a long-standing challenge in understanding how tiny defects in materials like diamond and silicon carbide behave when exposed to light. Their new computational method revealed a surprisingly important energy-loss mechanism in silicon carbide that scientists had previously underestimated. The finding helps explain a mystery that has puzzled researchers for years and could improve the design of quantum computers and sensors.

Cambridge scientists create a $10 chip that could put a medical lab on your wrist

Cambridge researchers have created a groundbreaking $10 optical sensor that delivers the precision of laboratory equipment in a device small enough for wearable technology. It identified foods, plastics, and medicines with 100% accuracy in tests and demonstrated the ability to monitor blood glucose, alcohol, and other health markers without invasive procedures.

Autonomy Where It Pays Off. Control Where It Counts.

Our position on long-running, autonomous agents, and why most business processes need a specialist instead.

Picture the person who has to sign off on your first autonomous agent. It might be your head of audit, your CISO, or the risk lead for the business unit that wants it. They ask one question: when this agent does something, who authorized it? If nobody can answer that cleanly, the agent stays in pilot.

That chair is where a lot of agentic AI gets stuck. In DataRobot’s Unmet AI Needs Survey 2026 of 413 agentic AI stakeholders, the question of whether existing access controls and catalogs are adequate to govern agents came out a coin flip: 49% said yes, 51% said no. Governance also topped the list of challenges companies expect when scaling from one agent to 100 or more, cited by 61%. And launch isn’t the finish line, since 94% of organizations hit Day 2 operational issues after deploying agentic AI. The workaround most teams reach for is a human clicking approve on every meaningful action. That doesn’t automate anything. It adds a new interface to the same bottleneck.

And the problem just got bigger, because a new class of agent has gone mainstream. These agents don’t wait to be invoked. They keep memory across restarts, run a loop between your messages, and act on their own initiative. Open-source projects like Hermes Agent popularized the pattern, and the big labs have followed: xAI shipped Grok Bot in August, Meta shipped Muse in September, and OpenAI launched Dots on September 29, and Anthropic launched Claude Duet on October 21.

That’s useful, and it’s a very different risk surface from a bounded pipeline that runs, answers, and exits. Our view is that the right level of autonomy depends on the problem, and you shouldn’t need a different platform for each answer. Here’s how we think about it.

Long-running and autonomous are two different properties

People tend to lump them together, but they’re worth separating. A long-running agent never turns off and keeps state across sessions, so it gets better at your environment over time instead of starting cold on every run. An autonomous agent can decide to act without a human approving that specific action: pick up a task, call a tool, spend tokens, write to a system of record, or message someone.

A dedicated agent flow, like a RAG pipeline or a ticket classifier, is usually neither. It’s invoked, runs a mostly fixed set of steps, returns an answer, and remembers only what was in the prompt. Hermes-style agents are both.

You’d want both when the problem is a standing responsibility instead of a single request. Take month-end close: pull the reconciliations, flag exceptions, chase owners, and escalate only what needs a person. You could stitch that together with scheduled jobs calling narrow pipelines, but you’d be hand-building the scheduling, the state, and the judgment about what’s worth escalating. A long-running agent handles that natively, and its context compounds as it learns your systems and conventions.

The trade is explicit. You give up a small, auditable surface area for a bigger one that can do more without you. That’s worth it for judgment-heavy, long-horizon work. It usually isn’t worth it for a well-defined, high-volume, cost-sensitive task that a guarded flow already handles at a fraction of the token spend.

The generalists have arrived

Grok Bot, Muse, and Dots make the same bet from three different labs: give every user an agent that keeps working on their behalf, with broad access and a standing goal. Grok Bot and Muse each give the agent its own cloud machine, and Dots connects to more than 4,000 apps and is pitched as able to do nearly anything. That breadth is the point. These are generalists, the office administrators of the agent world, and they’re impressive precisely because they aren’t specialized for anything.

That’s a fine trade for a person delegating their own errands. It’s a shakier one for a business process. A generalist reaches for a frontier model because it can’t know in advance which step is hard, so work a small model could do reliably runs on the most expensive one, on a loop. Breadth of access is also breadth of blast radius, and the vendors say so themselves: Grok Bot itself calls its shared machine, logins, and files “a real blast radius.” Consumer-first products also come with consumer-first defaults on data use and regional availability, which is a different bar from what your regulator expects. And their guardrails lean heavily on per-user approvals, while an enterprise needs policy that applies to every agent and every action whether or not someone remembered to click deny.

The alternative is a specialist. Compare a general-purpose coffee machine with a barista trained for one job: the same drink, made the same way, quickly, at a known cost, every time. A specialist agent knows its process, uses only the tools that process needs, and runs each step on the model that step actually needs.

What autonomy asks of your security team

An agent that acts on its own, remembers things, and keeps running between check-ins needs controls a stateless pipeline never did. It holds long-lived credentials because it has to act later, unattended, which makes those credentials a permanent target. Prompt injection turns into privilege escalation: a pipeline that reads a poisoned document produces a bad answer, but a long-running agent that reads one can open a PR, leak a secret, or message a customer. Memory becomes a durable attack surface, since one false fact written into it shapes every future session. And because behavior drifts as memory and skills evolve, a one-time code review isn’t enough; tracing has to be always on.

Then there’s identity, which nobody has solved cleanly yet. A human teammate logs in as themselves, and their access leaves when they do. A team agent is provisioned once and used by many, so when something goes wrong, “who authorized this?” has no clean answer. Its permissions tend to ratchet up and never come back down. It can spawn sub-agents or act on automated triggers, producing actions with no human originator at all. And it often ends up on one shared service identity, which erases per-user attribution right when an incident review needs it. The right posture looks like how you’d treat a highly privileged contractor: a named identity where possible, scoped and reviewed grants, short-lived tokens, and an audit trail that separates “the agent did this” from “the agent did this because a specific person asked.”

Autonomy is worth having, and governance is what makes it safe to adopt. That’s why it has to come first.

Where we land

We see two ends to this, and we’re building for both.

For the problems that are truly open-ended, where a self-learning agent with long-running memory earns its keep, run that agent inside your own governed perimeter: your data, your infrastructure, tracing from day one. Our Labs team is already showing how that works (more on that below). Save it for work where true autonomy is worth the spend.

For everything else, and that’s most critical business problems, you don’t need a generalist or open-ended autonomy. You need a specialist that executes the process, not one that drafts suggestions about it, with governance and approval gates built in. That’s the default, and it’s where we lead.

Decision Agents: the specialist, governed from the first run

Decision Agents are DataRobot’s specialists. Each one is built to make and carry out the decisions behind a specific business process, the ones that move a number the business already reports, across the systems, teams, and partners that process touches. Where a generalist is designed to handle anything, a Decision Agent is designed to handle one process correctly, every time, at a predictable cost.

Governance comes from the Agent Workforce Platform they run on, so it’s there from the first run instead of added after. Through the DataRobot LLM gateway, you choose the model for each task, which means routine steps don’t have to run on the most expensive frontier model. Guard models check the steps that matter, and human approval gates sit wherever you decide a person needs to sign off. Each agent gets its own identity and a named owner, and its secrets live in the DataRobot credentials store instead of in code. OpenTelemetry traces of model and tool calls give your audit team a record of what the agent did and why. And Decision Agents run where you need them: in the cloud, on-prem, or air-gapped, on your own infrastructure.

You get outcomes you can predict and spend you can plan for, without the standing risk surface of a long-running generalist. To see what that looks like, watch a scenario that takes a $2.5B supply chain crisis to competitive advantage in 72 hours.

See governed autonomy for yourself

For the open-ended end of the spectrum, DataRobot Labs has published two experimental open-source projects that show what a governed perimeter looks like in practice.

Hermes architecture diagram
Hermes architecture diagram

Hermes Agent on DataRobot runs the open-source Hermes agent as a DataRobot workload. It’s experimental and community-maintained, not an officially supported DataRobot product, but it shows the full pattern end to end. It deploys from git with the DataRobot CLI, and you can turn on automatic redeploys on every push. The web chat sits behind DataRobot login and sharing, and the optional Slack bot only answers an allow-list of users. Model calls go through the DataRobot LLM gateway, so the agent holds no provider API keys and you can pick the model per job. Secrets live in the DataRobot credentials store, and on GitHub the agent acts as a GitHub App with short-lived installation tokens. Model calls and tool calls are traced with OpenTelemetry.

Hermes on Datarobot single trace
Hermes on Datarobot single trace

datarobot-sync is the companion tool, also an experimental Labs project. It copies only what changed between a local directory and DataRobot Files, so an always-on agent keeps its skills, memory, and sessions across restarts.

Long-running, autonomous agents have a real future for the problems that are truly open-ended and worth the spend. They need governance, identity, and controls in place from day one, before the first incident rather than after it. For everything else, a specialist running a guarded, reviewable flow is the better engineering and business decision. Autonomy where it pays off. Control where it counts.

The post Autonomy Where It Pays Off. Control Where It Counts. appeared first on DataRobot.

Lab-grown mouse muscles enable tiny robots to jump, swim, walk and grasp

Lab-grown skeletal muscle tissue can contract, but the movement is often so slight that it is barely visible. This poses a problem for biohybrid robots designed to move using living muscles. Researchers at ETH Zurich have now demonstrated that it is not just the amount of muscle tissue that matters, but above all how the muscle and the artificial scaffold interact.

People are taking an unapproved weight-loss drug. AI found something surprising

Researchers analyzing nearly 150,000 Reddit posts uncovered unexpected symptom reports linked by users to unapproved versions of retatrutide, including increased appetite, sleep disturbances, and elevated heart rates. The findings differ from clinical trial results and highlight how AI could help identify potential drug safety signals that warrant further investigation.

Wheeled, flying and six-legged robots stay on track with new learning method

It's important for a robot not just to learn a task optimally, but to complete it without going off the rails of reasonable expectations. Until now, roboticists could have one or the other. Aerospace engineering researchers in The Grainger College of Engineering, University of Illinois Urbana-Champaign, combined reinforcement learning with control theory to guarantee robot stability and improve tracking performance by up to 15% compared with existing methods.

Sovereign AI is an architecture decision

What happens when the infrastructure your entire AI stack runs on becomes a liability? Not because it failed but because the politics around it changed.

For a growing number of enterprises, this isn’t hypothetical. Regulatory requirements are tightening. Data residency rules are multiplying. Governments are intervening in which AI tools can be deployed, by whom, and where.

And organizations that built their AI operations entirely on a single cloud provider’s platform are discovering a hard truth: they can use the tools, but they can’t guarantee they’ll keep using them. They can run workloads in a provider’s sovereign region, but they can’t separate the software from the provider who owns it.

It’s access on someone else’s terms, subject to someone else’s jurisdiction.

Most enterprises evaluating sovereign AI ask whether their cloud provider has a sovereign region. That’s a starting point. But the question that actually reveals your exposure: can your AI software run on infrastructure you fully control, with no dependency on the vendor’s cloud?

Sovereign regions have a ceiling

Cloud providers have responded by standing up sovereign regions: data centers in specific countries where data stays local and falls under local jurisdiction. It’s becoming table stakes, commoditizing fast as hyperscalers race to plant flags in regulated markets.

For a narrow definition of sovereignty, that may be enough.

But the enterprises facing the hardest sovereignty requirements are asking different questions.

  • Can a policy decision made in another country interrupt their AI operations? 
  • Does their AI software supply chain run through a jurisdiction they don’t control? 
  • Can they guarantee operational continuity if their vendor’s relationship with a government changes overnight?

Sovereign cloud regions can’t answer those questions. A sovereign region still runs on the cloud provider’s infrastructure, governed by their software, subject to their jurisdiction. Moving to a sovereign region changes where the data sits. It doesn’t change who controls the software stack above it.

Sovereignty has levels. Most enterprises are stuck at the bottom.

Sovereignty is a spectrum. At the lowest level, the requirement is straightforward: data stays in a specific geography. A cloud provider’s regional data center handles that. Most enterprises stop here and assume they’re covered.

But sovereignty requirements escalate. The next level asks whether the organization can operate independently of the provider. No third-country interference. No dependency on a vendor’s network, model registry, or update infrastructure. Above that, the question becomes whether any single vendor controls the software, the supply chain, or the AI system’s operational continuity.

Many enterprises, when they honestly assess where they sit on this spectrum, find themselves at the bottom. Data is in the right country, but the AI software still runs on a vendor’s platform, governed by that vendor’s infrastructure and update cycle. Operational continuity depends on that vendor’s continued access to the market.

The gap between where most enterprises are and where regulated industries need to be is architectural. The AI software is engineered to run on the provider’s cloud, and sovereign regions are a patch applied to that architecture: they extend reach without changing the dependency.

Fused vs. decoupled: the architecture decision that sets your sovereignty ceiling

There are two fundamentally different ways to build an AI software platform.

The fused architecture is what hyperscalers build and sell. The AI software, the models, the governance tooling, the agents: all of it is built into the provider’s platform. Some of it now runs on-premises or even air-gapped, but only on the provider’s own hardware stack, with the provider’s models and a curated subset of services. Wherever it runs, the software above the infrastructure line still belongs to the provider.

The decoupled architecture separates the AI software layer from the infrastructure entirely. The platform (agents, governance, MLOps, model registry) runs as a portable layer that drops onto whatever infrastructure the enterprise controls. On-premise. Air-gapped. A virtual private cloud. A partner’s hardware. The same platform and the same governance run in every environment.

Decoupled vs fused architecture comparison image by DataRobot

At the bottom of the spectrum, where the requirement is data residency, both architectures compete.

As sovereignty requirements escalate toward operational independence and full supply chain control, only the decoupled architecture qualifies. The fused architecture hits a structural ceiling it can’t engineer its way past.

Every industry has a sovereignty exposure

One of the most persistent misconceptions about sovereign AI is that it’s a public-sector concern. Government contracts, defense procurement, regulatory compliance. While these are very real sovereignty use cases, they’re also a fraction of the exposure.

Any enterprise that has built workflows, products, and operational dependencies on a single provider’s platform has a concentration risk. If anything disrupts that provider relationship, whether regulatory, geopolitical, or commercial, the enterprise has no ability to respond independently.

That’s a business continuity issue, and it belongs in the same conversation as supply chain resilience and operational redundancy.

The economics point in the same direction. At sustained inference volumes, owned or dedicated GPUs often cost less than on-demand cloud capacity. Sovereignty and cost efficiency are converging on the same answer: run AI on infrastructure you control.

Every enterprise runs on some mix of cloud, on-premise, and hybrid infrastructure. An AI platform that can move across all of them, without rebuilding governance or renegotiating vendor relationships, is both a sovereignty property and a business resilience property.

Two questions to ask every AI vendor

Most vendor conversations about sovereign AI focus on geography: which regions, which data centers, which countries. That tells you where the data sits. It tells you nothing about the architecture above it.

Two questions cut through that:

  1. If your company lost access to a market overnight, could your AI operations continue uninterrupted?
  2. If you needed to run the platform completely air-gapped from the vendor’s network, could you? And what would you lose?

The answers will separate vendors whose AI software is portable from vendors who have bolted sovereign features onto a cloud-dependent platform. The difference becomes obvious fast.

What sovereign AI actually requires

Sovereign AI at the levels that matter for regulated enterprises is an architectural property of the software. The platform can either run independently of any single infrastructure provider, or it can’t. No amount of sovereign regions changes that.

A decoupled platform runs on infrastructure the enterprise already owns or selects independently. The platform is designed to stay the same when the infrastructure underneath changes. That’s the difference between a platform you depend on and a platform that works for you.

For organizations in energy, manufacturing, defense, and any enterprise whose sovereignty requirements extend beyond data residency, the honest assessment is that a fused cloud platform has a ceiling. A decoupled architecture doesn’t.

(CTA)  The architecture decision you make today locks in your operational control for the next decade. The enterprise agentic AI architecture framework covers the governance, deployment, and runtime decisions that determine how much control your organization retains.

The post Sovereign AI is an architecture decision appeared first on DataRobot.

ACM SIGAI Autonomous Agents Award 2027 open for nominations

ACM SIGAI logo
Nominations are solicited for the 2027 ACM SIGAI Autonomous Agents Research Award. This award is made for excellence in research in the area of autonomous agents. It is intended to recognize researchers in autonomous agents whose current work is an important influence on the field. The award is an official ACM award, funded by an endowment created by ACM SIGAI from the proceeds of previous Autonomous Agents conferences. The recipient of the award will receive a monetary prize and a certificate, and will be invited to present a plenary talk at the AAMAS 2027 conference.

How to nominate

Anyone can make a nomination. Nominations should be made by filling out this google form, and should consist of a short (< 1 page) statement that emphasizes not only the research contributions that the individual has made that merit the award but also how the individual’s current work is an important influence on the field.

Note: a candidate can only be considered for the award if they are explicitly nominated. If you believe that someone deserves the award, then nominate them – don’t assume that somebody else will!

Nomination link is here.

Important Dates

5 December 2026 – Deadline for nominations
1 February 2027 – Announcement of winner
3-7 May 2027 – AAMAS-2027 conference in Hanoi, Vietnam

For any questions please contact Sven Koenig (Award Chair) or Louise Dennis (SIGAI Vice Chair).

Robot AI predicts future scenes to guide its next moves

A robot artificial intelligence (AI) system has been developed that can understand human instructions, predict what a scene will look like after an action and then carry out the task. Rather than simply translating instructions into physical movements, the technology also uses the anticipated outcomes of those actions to control the robot.
Page 3 of 56
1 2 3 4 5 … 56