InfoWorld

Technology insight for the enterprise
  • The pitch sounded perfect. A large regional distributor needed to build a new sales transaction management system. The goal was straightforward: automate parts of order intake, discount approvals, exception handling, customer communications, and inventory checks. It was not a trivial system, but it was also something the industry had built before.

    Then the vendor presentations began. Every software provider seemed to have a new agentic AI story. Their platforms had agents that could make decisions, orchestrate workflows, interpret customer intent, route exceptions, and learn from business context. One vendor described its offering as a common LLM brain that could make decisions as if the company had hired 10,000 experts, except those experts were not on the payroll. That line was from an actual sales pitch, and it landed well in the boardroom.

    The company decided to go agentic. The architecture would use AI agents to manage decision flows, invoke tools, check policies, interact with enterprise systems, and escalate only when needed. It looked modern. It looked strategic. It looked like the future. Then reality arrived.

    Building the system required far more integration work than expected. Each agent needed access to clean data, governed APIs, business rules, security controls, observability, exception handling, and human override mechanisms. The team had to build guardrails around decisions, logging around reasoning, test harnesses for unpredictable outcomes, and new operational processes for things traditional systems handled more predictably.

    Costs ballooned. Security reviews took longer. Operational complexity increased. The project ultimately ran fine once in production, but six months later, the company realized the uncomfortable truth: the system cost roughly 20 times more than a traditional architecture would have cost when all supporting complexity was included, and it delivered about the same ROI.

    I am hearing versions of this story once or twice a week from clients, colleagues, and friends. Agentic AI is powerful. It is also being pushed into places where simpler technology would deliver the same business value for far less money.

    Doomed to repeat history

    None of this is new. The names change, the diagrams change, the conference sessions change, but the pattern is familiar. A technology or architectural approach emerges. It solves a real problem. Early adopters show impressive results. Vendors package it. Analysts name it. Thought leaders explain it. Conferences celebrate it. Then, almost overnight, every enterprise architecture discussion starts with the trend instead of the business problem.

    We saw this with cloud-native. We saw it with microservices. We saw it with service-oriented architecture. We saw it with distributed objects, CORBA, and other approaches that promised flexible, reusable, distributed systems.

    Each of these patterns had value, and each solved real problems. Each also caused expensive failures when adopted as a default answer rather than as a fit-for-purpose architecture.

    SOA sold us reuse and flexibility

    Service-oriented architecture was a good idea. Break capabilities into services. Expose them through contracts. Reuse business functions across applications. Reduce duplication. Create an architecture that could evolve.

    The plus side was real. SOA gave enterprises a language for service reuse and integration. It pushed teams away from tightly coupled monoliths and point-to-point chaos. It helped organizations think in terms of business capabilities rather than just applications.

    The minus side was also real. SOA became expensive and complex very quickly. Enterprise service buses turned into central chokepoints. Governance became heavyweight. Teams spent more time debating service contracts, standards, registries, and middleware than delivering business features. In many companies, SOA became an architecture tax.

    It fell short because the cost of doing it “properly” often exceeded the value of the reuse it promised. We do not talk about SOA as much today because much of it was absorbed into APIs, integration platforms, and service-based design. The label faded after too many projects became too large, too slow, and too expensive.

    Microservices promised speed

    Microservices arrived as the antidote to large, slow systems. Smaller services. Independent teams. Independent deployment. Better scalability. Faster change.

    Again, the pluses were real. For organizations with strong devops practices, mature automation, disciplined domain boundaries, and high-scale needs, microservices worked well. They allowed teams to move independently and scale parts of systems without scaling everything.

    The minuses were predictable. Many companies took ordinary applications and shattered them into dozens or hundreds of services. They traded code complexity for network complexity. They created distributed failure modes, data consistency problems, monitoring challenges, testing headaches, and operational overhead they were not prepared to manage.

    Microservices were often sold as a path to agility. In many enterprises, they became a path to higher cloud bills, more meetings, and slower troubleshooting. The industry learned painfully that microservices are not a maturity shortcut. They require maturity first.

    Cloud-native sold us modernization

    Cloud-native architecture, containers, and Kubernetes brought another wave of enthusiasm. The idea was compelling: portable workloads, declarative deployment, elastic scaling, automated recovery, and a modern operating model.

    The plus side is still strong. Containers are useful. Kubernetes is powerful. Cloud-native patterns can support resilience, portability, and rapid deployment. For high-scale digital businesses, platform teams, and applications requiring elastic operations, the value is obvious.

    The minus side is cost and complexity. Many enterprises moved systems into containers and Kubernetes without a clear reason. They added clusters, service meshes, observability stacks, platform engineering teams, security layers, and specialized skills. In many cases, the architecture nearly doubled the cost of running systems that did not need that level of abstraction.

    Cloud-native is often excellent architecture, but it is not universally applicable. That distinction got lost when every vendor, every consulting firm, and every internal technology strategy suddenly had to be cloud-native.

    Agentic AI is next

    Agentic AI is now moving through the same cycle. The potential is real. Agents can automate complex workflows, reason across data, interact with tools, and support tasks that were difficult to automate a few years ago.

    The danger is that enterprises will assume agentic AI belongs everywhere. It does not.

    Agentic systems add costs that traditional systems often avoid. They require model access, prompt management, tool orchestration, evaluation frameworks, security controls, audit trails, human-in-the-loop design, data governance, and new operational skills. They introduce nondeterministic behavior into processes that may require deterministic outcomes. They can make simple automation much more expensive than it needs to be. In some cases, the value will justify the cost. In many cases, it will not.

    Value comes first

    Enterprises should start with value, not architecture. If agentic AI reduces labor, improves customer experience, handles exceptions better, or enables a capability that traditional systems cannot deliver economically, then it deserves serious consideration. But the value must be measurable. Vague promises of automation are not enough. If a traditional workflow engine, rules platform, API integration, or conventional application can deliver the same result at one-tenth the cost, that matters.

    Agentic AI works best where the problem requires interpretation, adaptation, and semi-autonomous action. It is less compelling when the process is stable, rules-based, highly regulated, or easily expressed through traditional logic. Enterprises need to separate impressive demos from practical use cases. A system that looks intelligent in a conference demo may be expensive, fragile, and hard to govern in production.

    Use cases matter. Skepticism is healthy.

    Every architecture has positives and negatives. The mistake is pretending otherwise. SOA gave us value and complexity. Microservices gave us agility and operational burden. Cloud-native delivered scalability and cost expansion. Agentic AI will have automation benefits along with governance, security, and operations challenges.

    The job of enterprise architects is not to follow the trend. It is to understand the trend, test it against business value, and apply it only where it fits. Otherwise, we are destined to make the same mistakes over and over again.

  • The most dangerous actor in a software supply chain may now be an automated script with powerful credentials and no idea where it’s sending them.

    Researchers from pen-testing company Cycode have discovered a now patched critical zero-click supply chain vulnerability in the open-source Windows Package Manager (WinGet), which sits on billions of devices worldwide.

    A single pull request could have tricked Microsoft’s internal tooling into freely handing over a moderator’s GitHub access token, with no phishing, no malware, no moderator clicking or approval required.

    There is currently no evidence that the flaw has been exploited in the wild. But it serves as a cautionary tale for enterprises that the automation they trust is becoming an attacker entry point, and package repositories are particularly enticing targets.

    “Package registries have become the highest-profile target in the software supply chain,” Moriel Harush, Cycode security research lead, wrote in a blog post. “Compromise a single maintainer, and you reach everyone who trusts them. Compromise the gatekeepers, and you reach the entire ecosystem.”

    Whatever the employee can do, the attacker can do

    WinGet is Microsoft’s free, open source command line tool that helps users discover, install, upgrade, configure, and remove apps. It exists on more than 1.4 billion active devices running Windows 10, Windows 11, and Windows Server 2025.

    WinGet’s catalog is a public GitHub repository, and its gatekeeper, so to speak, is a small, official group of Microsoft moderators who review a constant stream of community pull requests and proposed changes. By default, WinGet installations on every Windows machine trust the actions those keepers take.

    The hole is in the moderators’ own internal triage tool. This PowerShell helper attached the moderator’s secret GitHub Personal Access Token (PAT) to any HTTP request, without checking who owned that address.

    This meant an attacker merely had to supply an address. Theoretically, if they opened a pull request and pointed an InstallerURL software installation package at their own server, “the trap was set,” Harush explained.

    Microsoft’s automated Azure DevOps validation pipeline would then attempt to fetch the URL, but the attacker’s server would intentionally return an error. This added a validation error label to the pull request.

    The moderator’s internal script would respond to that label by running a CheckInstaller routine which would send a HEAD request to the attacker via an authenticated HTTP helper, whose job is to automatically attach credentials or tokens to outgoing HTTP requests and handle authorization errors. Then all the attacker had to do was check their logs and extract the moderator’s official GitHub token, which was “casually” handed over. 

    But the token is not merely a repository-scoped credential, it is a full identity credential, meaning whatever that Microsoft employee can do on GitHub, the token can do.

    Harush explained: “It is like a courier stapling your house key to every parcel that has your name on it, because most of them are destined for your own address.” But if a stranger uses your name and changes the address to one they control, “your key is delivered directly to them.”

    Armed with this key to Microsoft’s internal environment, an attacker could push malicious manifests, approve their own pull requests, and slip in backdoored installers to 14,000 exposed packages, all under a highly trusted, official Microsoft badge.

    They could also access and write to every other Microsoft repository the moderator had access to, modify GitHub Actions workflows across those repositories to achieve remote code execution (RCE) and exfiltrate corporate secrets.

    There is a precondition for this attack: At least one moderator has to have the triage tracker running in a continuous background loop, which it is designed to do as it waits for work.

    Underlying model ‘fundamentally flawed’

    Harush pointed out that Microsoft’s C# version of the tool, in the same directory, did not share the flaw; as such, it would have offered safer authentication. Microsoft has since patched the PowerShell vulnerability, safely scoping the authentication mechanism to ensure that users’ tokens are only attached when a request host is an authorized GitHub endpoint, such as api.github.com, github.com, or raw.githubusercontent.com.

    Harush noted, however, that the underlying credential model is “fundamentally flawed,” and that relying on Classic PATs is a “severe liability.”

    Cycode advises binding credentials to destinations, rather than functions; auditing every internal tool that handles maintainer credentials; and ensuring that headers are conditionally applied based on the target host, “not unconditionally stapled by a wrapper function.” Treat all user inputs as hostile, validated hosts before credentials are attached, and deprecate classic PATs.

    “The blast radius of a leaked token must be limited to one repository and the bare minimum permissions,” Harush said. “A leaked token should never mean a leaked corporate identity.”

    He emphasized, though, that WinGet moderators are doing exactly what’s asked of them: Using automated tools to manage a “flood of community submissions” and make their jobs easier. “But automation does not just remove the human who would have clicked the malicious link; it removes the human who would have noticed the anomaly.”

    Scripts are a soft spot

    The WinGet flaw was a near miss, but “a very serious one,” said Frank Dickson of Dickson Research. Exploiting it would have let an attacker publish malware with “Microsoft’s seal of approval.”

    This means attackers could have pushed tampered installers to anyone who ran an install or an update, reached into any other Microsoft repositories the moderator could touch, and hijacked the build machinery to steal more secrets.

    And the damage would have looked like routine work. An IT team scripting a standard software rollout would have installed the attacker’s code on every machine, and the logs would have shown an approved package from an approved source.

    “The attack would have been a Trojan horse delivered by the mail carrier everyone trusts,” Dickson said.

    Enterprise security teams should learn that their own scripts are a soft spot, he pointed out; internal tools, bots, and automation get production-level keys and hobby-level review. CISOs should inventory every script and bot that holds a token, and answer important questions: What could this key do in the wrong hands? Where is it allowed to go?

    Additionally, he advised replacing broad, long-lived tokens with narrow, short-lived ones, and binding every credential to the specific services that need it, which is exactly how Microsoft fixed this problem. “Also, enterprises should stop trusting public registries blindly,” Dickson said.

    Ultimately, security teams should review their automations the way they review their people, he said. “A script that runs in a loop around the clock with a moderator’s keys is, in effect, a moderator who never sleeps and never questions anything.”

    This article originally appeared on CSOonline.

  • AI coding tools are moving beyond copilots that make suggestions to independent, autonomous agents that execute terminal commands, write and modify software, run tests, and install dependencies.

    This means they need the freedom to move around on their own, but that is inherently dangerous; agents with little oversight or unrestricted access can make changes they aren’t supposed to, expose credentials and other sensitive information, or take other unintended actions, as vendors have discovered the hard way.

    To help move the bar on these security and governance challenges, the Eclipse Foundation has launched Eclipse Enclave 1.0, an AI sandbox and runtime. Developers can use the vendor-neutral platform to test various autonomous AI coding tools in isolated environments, with explicitly defined access to files, credentials, and networks.

    The alternative has been to keep the agent on a “very short leash,” which requires developers to approve every action, said Thabang Mashologu, CMO and head of products at the Eclipse Foundation. And at that point, you’re losing a lot of the productivity benefits of having an autonomous agent in the first place.

    “Ultimately, developers shouldn’t have to choose between agent productivity and security,” he said.

    More independent work, less supervision

    The Eclipse Foundation is a non-profit chartered in the EU that supports and governs more than 450 open source software projects. That now includes Eclipse Enclave 1.0, which currently supports Claude Code, Codex, OpenCode, GitHub Copilot CLI, Pi, and Eclipse Theia. Its extensible architecture allows for additional tool integration.

    Developers can run agent sessions in isolated containers, allowing them to work independently but with limited access to sensitive files and resources. Built-in mechanisms help protect API keys and OAuth tokens for third-party services.

    Users can give the agent access to exactly what it needs for a particular task, such as project source files, selected documentation, or web resources, plus a curated list of development tools, Mashologu explained.

    “Everything else on your development machine, such as SSH keys, tokens, and other source files, remains out of reach of the agent,” he said.

    One example use case would be that of an agent given the task of refactoring a fairly substantial piece of code. It should be able to explore the codebase, make changes, install whatever dependencies it needs, run tests, execute ad-hoc scripts to obtain and analyze runtime logs, and keep iterating until it’s done, Mashologu said.

    “That’s exactly the kind of work where agents can save developers a lot of time,” he noted. “But it’s also the kind of long-running task where you might be uncomfortable giving an agent unrestricted access to your machine without supervision.”

    Multiple agents can also be run in parallel on separate tasks in Enclave, but their work is isolated, making it simpler to review. Developers have model choice and persistent sessions, so they can resume work without losing progress or configuration. The platform integrates a preview of HomeShell, a UI that manages multiple parallel sessions in project workstreams.

    For instance, one agent may be delegated to perform a bug fix, another may write tests, and a third may handle a refactoring task. “Each can work in its own worktree and isolated environment without interfering with the others,” Mashologu explained.

    Developers still review the work before merging it, but the difference is that they’re able to spend more time defining needed changes and evaluating results, and “less time supervising every step along the way,” he said.

    Eclipse Enclave 1.0 also gives developers: 

    • Rootless session operation on Podman and Docker.
    • Network visibility: Traffic from all sessions goes through a gateway with an allowlist; the log allows users to review what the agent tried to reach.
    • Access to tools and features straight from git repositories. A separate enclave-extensions repository provides more harnesses (like Antigravity), sandbox features, and developer tooling (like Playwright MCP). A VNC viewer provides the ability to operate UIs within the container, and extensions can add commands, such as `enclave vnc-viewer`.
    • Binaries for Linux and macOS (including arm64), deb and rpm packages, and a launcher for Windows via WSL2.
    • Self-updates with a stable and a rolling channel, with releases published on the Eclipse download site.

    Changing how developers focus their attention

    Enclave was first developed by EclipseSource, an Eclipse Foundation member that builds custom tools and integrated developer environments (IDEs), in late 2025 as an internal tool. Its developers quickly began using it daily, so it wasn’t a “purely theoretical exercise,” Mashologu noted.

    The company then observed a shift in where developers focused their attention, he explained. Previously, repeated approval prompts interrupted their flow, and agents stalled whenever they couldn’t respond immediately. “Defining access rules upfront, in line with company policies, reduced the need for that constant babysitting,” Mashologu said.

    Using the tool, developers could spend more time thinking through what agents should accomplish, the architecture required for those tasks, the constraints they must respect, and how they could prepare the tools, context, and checks agents needed to complete and verify their tasks.

    “They found that this also made it more practical to delegate several tasks to multiple agents in parallel, with developers focusing on shaping the work and steering the results,” Mashologu said.

    EclipseSource, which has been actively involved in the open-source ecosystem for more than 15 years, contributed the platform to the Eclipse Foundation in July 2026, and its team has continued developing it, incrementally porting more and more features from its internal tooling.

    “Making Enclave open source creates an opportunity for others to contribute, scrutinize the technology, and help shape its direction,” Mashologu observed.

    Better tools to manage the risk

    Still, it’s relatively early in the evolution of agentic development, he acknowledged, and it’s important not to overstate what sandboxing can do. It helps define clear borders outside of the AI harness and contain risk, but doesn’t eliminate it. Developers still have to think carefully about permissions, network access, dependencies, and the quality and security of the code agents produce.

    “We’re not suggesting that Enclave makes autonomous agents completely safe,” Mashologu said. “It’s about giving developers better tools to manage the risks.”

    The bigger issue

    Ultimately, the project highlights what the Eclipse Foundation considers a much bigger issue: Who controls the infrastructure that AI agents rely on. It shouldn’t be controlled by any one vendor or tied to any particular AI model or development tool, Mashologu said.

    As agents become more autonomous, the systems that determine what they can access, what they’re allowed to execute, and how they interact with the outside world become incredibly important, he pointed out. “It’s not enough for the AI models themselves to be powerful. We also need open, trusted infrastructure around them.”

  • Cloud teams spend a lot of time and money designing applications to withstand failure. Replication, versioning, snapshots, and infrastructure as code (IaC) keep applications available and cloud environments more resilient. The trouble starts when teams assume those same capabilities will also allow them to recover from a cyberattack.

    In September 2026, Microsoft detailed an incident in which attackers used compromised Azure identities to delete cloud resources and target recovery protections. In a destructive sequence lasting about seven minutes, attackers attempted more than 100 deletions of storage accounts and deleted most of them. The attack shows how easily an attacker with sufficient privileges can turn cloud management capabilities against the organization.

    In talking with customers, I’ve learned they typically take one of two paths. Some spend heavily on disaster recovery because they’re worried about the next hyperscaler outage, while others assume that data sitting in AWS or Azure is already sufficiently protected. Both sides often misunderstand what cloud-native resilience tools were designed to do. Those tools behave differently when the disruption comes from an attacker instead of an outage.

    Here are six misconceptions I hear most.

    Myth 1: Amazon S3 versioning is the same as backup

    Versioning is useful when someone accidentally overwrites or deletes an object, but not when an attacker has your credentials. In January 2025, researchers at Halcyon documented the Codefinger ransomware campaign, in which attackers used compromised AWS credentials and Amazon S3’s server-side encryption with customer-provided keys (SSE-C) to make data inaccessible, then threatened deletion through S3 life-cycle policies.

    You should know who can change the controls protecting your data, particularly when the credentials used to access production can also alter life-cycle policies or other S3 settings. Restrict those permissions and use protections such as Object Lock or MFA Delete to limit the damage a compromised identity can cause.

    Myth 2: Multi-region replication protects me

    Replication keeps applications and data available when infrastructure fails, which makes it an important part of cloud resilience. But a copy in another region isn’t automatically a clean copy.

    Whether you’re using Amazon S3 replication, Azure Storage georedundancy or another cloud service, replication is designed primarily for availability, not protection against every form of data loss. Depending on the service and configuration, corrupted or encrypted data may be replicated along with legitimate changes. And deletion behavior varies across services. Find out what your replicas do when the original changes or disappears. For critical data, keep recovery copies in a separate account that production credentials cannot reach.

    Myth 3: Snapshots are good enough

    Snapshots have the same issue. Teams can have plenty of snapshots and still find during an attack that they cannot recover from it. Code Spaces, a code-hosting service, had this problem in 2014, when an attacker gained access to its AWS control panel and deleted data, backups, machine configurations and snapshots. The company shut down within days.

    If an attacker who compromises a production account can also reach the recovery snapshots, the attacker can delete them too. Lock your recovery snapshots so no one can delete them before their retention period ends, not even an admin.

    Myth 4: IaC means we can rebuild anything

    Infrastructure as code makes it easier to recreate cloud environments quickly and consistently, but that only gets you so far. For example, Terraform can rebuild the database infrastructure, but restoring customer records, transaction history, and other critical information requires a separate data recovery solution.

    Recovery tests need to go further than redeploying the infrastructure. I recommend restoring the data the app depends on, then checking that the restored environment works.

    Myth 5: We’re stateless, so we don’t really have data to protect

    Applications described as “stateless” still write data somewhere and usually in several places. Customer records may be in a Postgres database and objects in Amazon S3. Other critical information might live in DynamoDB, Redis, Snowflake, or Apache Kafka.

    You should map the services each application writes to. Decide what data needs to be recoverable, and make sure someone is responsible for protecting it. Otherwise, important data can fall through the cracks between teams.

    Myth 6: Our data is ephemeral, so it doesn’t matter if we lose it

    Some data looks expendable until you need it. Audit logs are a good example. During an incident, security teams use them to determine what an attacker did, what was affected, and whether it is safe to start restoring.

    Rather than assuming that data is disposable, ask what losing it would cost. Could it stall an investigation, interrupt operations, impact revenue, or create regulatory problems?

    Include audit logs and other operational records in data retention and recovery planning, with access controls that prevent compromised production credentials from deleting them.

    Where native tools fit

    Native cloud tools do what they were designed to do, which is keep data available. Recovering from an attack is a different job. Whatever you use, ask two questions. Could someone with stolen production credentials delete your recovery copies? And have you actually restored from them?

    In a cloud incident, the first question from executives is “When will the business be back online?” The team doing the work often doesn’t know yet how much is damaged or whether anything is safe to restore. Know what your cloud tools can and can’t recover before you get asked that question.

    —

    New Tech Forum provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send allinquiries to doug_dineley@foundryco.com.

  • Microsoft is enhancing its Foundry IQ knowledge retrieval service with knowledge graphs, a specialized retrieval model and automatic infrastructure provisioning, seeking to make it easier for developers to build AI agents that can access, understand and reason over enterprise data.

    Grounding AI agents in organizational data is critical for enterprises to ensure they can deliver responses based on accurate, relevant, and up-to-date business information as they look to increasingly automate business workflows.

    The new knowledge graphs in Foundry IQ, announced at the Microsoft Ignite conference, will help agents connect related entities and facts across documents and organize enterprise content into topics, allowing them to answer questions that require information from multiple sources, the hyperscaler wrote in a blog post.

    In order to map relationships across documents, developers can add a graph configuration containing their ontology to an existing Foundry IQ knowledge source or bring an existing graph into the service. Foundry IQ then uses the ontology to map how documents, contacts, and information relate, while recording the source of each connection, it added.

    Alongside knowledge graphs, which are currently in public preview, the hyperscaler is adding a new retrieval model named Microsoft-Retriever-1 to reduce the number of searches and the reliance on large language models (LLMs) for retrieval planning in an effort to help developers lower latency and token consumption.

    The new model, according to the hyperscaler, interprets user queries, reformulates them using terminology found in enterprise documents, and determines whether additional searches are needed to retrieve relevant information.

    Developers can enable it on existing Foundry IQ indexes and knowledge bases without requiring additional provisioning or document reindexing, the hyperscaler wrote.

    Additionally, to simplify deployment of Foundry IQ, Microsoft is adding a capability that will automatically provision a managed Foundry IQ resource in every new Foundry project.

    This means developers will no longer have to provision or manage a separate Azure AI Search resource to create knowledge bases and connect AI agents to enterprise data, the hyperscaler wrote.

    The managed service, which will enter public preview in December 2026, will handle the underlying retrieval infrastructure through a usage-based, serverless pricing model, it added.

    Reduced developer workload

    The combination of the three new capabilities is expected to simplify how developers build AI applications and agents and ground them in enterprise data, analysts pointed out.

    “Until now, retrieval could find documents that resembled a question, but it could not follow the connections between them. In response to a question about which products a new regulation affects, a standard search returns the regulation and perhaps a few documents that mention it, leaving the developer to stitch together the chain from rule to supplier to product,” said Ashish Chaturvedi, executive research leader at HFS Research.

    “In contrast, knowledge graphs let agents trace that chain themselves and cite each link along the way, reducing the need for developers to manually connect information and build retrieval logic for complex questions,” Chaturvedi added.

    The Retriever-1 model, too, could reduce the effort developers spend on building retrieval logic for agents searching across multiple enterprise data sources, according to Stephanie Walter, practice lead of the AI stack at HyperFrame Research.

    “It handles decisions such as where to look, what to ask next, and when enough evidence has been gathered, eliminating the need for developers to write that logic manually,” Walter said.

    Similarly, automatic resource provisioning is likely to help developers reduce their efforts in building AI agents grounded in enterprise data by eliminating the need to set up the underlying retrieval infrastructure, according to Chaturvedi.

    “Grounding agents in company data usually means provisioning a search service, connecting sources, and configuring indexes before any real work begins. Having it ready from the start, on pay-as-you-go pricing, lets developers prototype grounded agents immediately and pay only for what they use,” he said.

    Boosting the scalability of enterprise AI

    Beyond simplifying development, the three updates could help CIOs improve the reliability, economics, and scalability of deploying AI agents across enterprise workflows, analysts noted.

    Knowledge graphs, for one, could help CIOs scale enterprise automation by giving AI agents richer context across enterprise documents, enabling better-informed decisions and more reliable execution of complex workflows, according to Chaturvedi.

    Potential applications include regulatory compliance, supply chain risk, contract analysis, and M&A due diligence, where decisions often depend on connecting information across multiple sources, Chaturvedi said.

    The Retriever-1 model, too, could help CIOs scale automation as it can help improve the economics of running AI agents at scale, Walter pointed out.

    “By using a specialized model for retrieval rather than relying on larger, general-purpose models for every task, enterprises could reduce the overhead of agent-driven applications while improving their responsiveness. This could make it more economically viable to deploy agents across a wider range of enterprise workflows,” Walter said.

    Similarly, automatic resource provisioning could help CIOs establish a more consistent and governed approach to connecting AI agents to enterprise data.

    “When every project starts with the same retrieval service, CIOs get more consistency in how agents access information and fewer homegrown search setups to secure and maintain,” Chaturvedi said.

    The usage-based pricing model could also lower the cost of experimentation, since unused projects would not carry standing infrastructure charges, Chaturvedi added.

    Accuracy and cost concerns

    However, the three capabilities are also likely to introduce trade-offs.

    For knowledge graphs, the primary concern is the accuracy of the entities and relationships identified across documents, Chaturvedi said: “Automated extraction can misinterpret industry jargon, abbreviations, or inconsistent naming, potentially leading agents to draw incorrect conclusions.”

    “Developers, therefore, will need to verify that the graph reflects actual business relationships and keep it updated as documents change. Graph-based answers can also take longer and cost more to generate than conventional searches, making them better suited to complex queries than routine lookups,” he added.

    For CIOs, though, the bigger worries will be around Microsoft-Retriever-1 and automatic resource provisioning, particularly their implications for cost predictability and dependence.

    “The Microsoft-Retriever-1 model could introduce additional latency and processing costs through iterative searches, as each additional retrieval round requires more search operations and processing. That means its benefits will depend on how effectively it determines when enough evidence has been gathered,” Chaturvedi said.

    “Hence, enterprises should also test it against their own data, as Microsoft has not published detailed performance comparisons. The model’s retrieval decisions may also be harder to inspect than developer-written search logic”, he added.

    Automatic resource provisioning, meanwhile, could deepen enterprises’ dependence on Microsoft’s retrieval stack by making it the default starting point for new Foundry projects, the analyst pointed out.

    There could be concerns around its usage-based pricing as well, according to Walter.

    “Usage-based pricing could also become less predictable as agents run continuously, requiring CIOs to establish spending limits and eligibility criteria for which projects use the service,” she said.

Sigma Connect

sigmaway forums

Forum

Raise a question

Access Now

sigmaway blogs

Blogs

Blog on cutting edge topics

Read More

sigmaway events

Events

Hangout with us

Learn More

sigmaway newsletter

Newsletter

Start your subscription

Signup Now