AIToday
Large Language ModelsAI Coding AssistantsAI Business & IndustryAmazon AI BlogPublished: Aug 11, 2026, 04:00 JST5 min read

nOps ships FinOps agents 75% faster with Amazon Bedrock AgentCore

nOps ships FinOps agents 75% faster with Amazon Bedrock AgentCore

Key takeaway

  • nOps rebuilt its Clara FinOps agent on Amazon Bedrock AgentCore and cut development time from 10–12 months to 4 months.

  • The company, which manages over USD $4 billion in cloud spend for customers across AWS, GCP, and Azure, replaced a self-managed Kubernetes infrastructure with a managed agent runtime, eliminating latency and operational overhead.

  • The new architecture uses Databricks for governed analytics and real-time workflows, allowing the team to ship features faster while maintaining high reliability.

3 Key Points

  1. What happened

    nOps, a cloud optimization platform, rebuilt its Clara FinOps AI agent on Amazon Bedrock AgentCore—a managed service for building and scaling agents—replacing a self-managed Kubernetes setup. The transition cut time-to-production from 10–12 months to 4 months, and the company now runs 4–6 production-ready agents on a single shared runtime.

  2. Why it matters

    nOps serves customers managing more than USD $4 billion in cloud spend across AWS, Google Cloud, and Azure. By moving to a purpose-built agent runtime with built-in memory and orchestration, the company eliminated infrastructure friction (API latency, system complexity, and engineering overhead on maintenance), freeing the team to focus on product features rather than infrastructure upkeep.

  3. What to watch

    The new architecture uses Databricks Lakehouse Metric Views for governed analytics semantics and Databricks Lakebase for durable application state, plus async workflows with DynamoDB and WebSocket push for real-time UI updates on long-running tasks. Clara now learns user preferences and organizational context over time through AgentCore memory.

In Depth

Read the full story

nOps, an AI-powered cloud optimization solution, recently transitioned its FinOps analytics and agent experience to Amazon Bedrock AgentCore, a managed service for building and scaling agents with any framework or model. The company now better serves customers managing commitment optimization across AWS, Google Cloud Platform, and Microsoft Azure, supporting more than USD $4 billion in cloud spend under management.

Before the transition, nOps deployed Clara, its FinOps AI agent, on top of existing infrastructure including Kubernetes, Amazon Bedrock model invocation, LangChain/LangGraph orchestration, and tool wrappers around web APIs. While this allowed rapid initial delivery, it revealed structural limits: API-shaped data and large context windows increased turn latency, multiple non-purpose-built layers made iteration and debugging harder, and agent answers were tied to API responses instead of a dedicated semantic analytics layer. As Jordan Stein, an nOps leader, explained: "We were attempting to build advanced AI capabilities on top of infrastructure that wasn't designed for analytics-driven agents, which made iteration slow, complex, and prone to inaccuracies."

The new architecture centers on four layers. The interaction layer is a Vercel-hosted Next.js web application where customers interact with Clara through a conversational interface backed by streaming Server-Sent Events. The agent runtime layer runs Amazon Bedrock AgentCore with a single Strands-based agent that has direct tool access for canvas operations, query execution, datasource discovery, and workflow orchestration—avoiding the latency and error-propagation overhead of multi-agent routing. The data layer uses Databricks Lakehouse Metric Views to provide a governed semantic analytics layer; for example, a metric view called "true_customer_cost" pre-models complex business logic (amortized cost, EDP discounts, PPA credits, RI and Savings Plan components) so queries are simple and consistent across chat and dashboards. Databricks Lakebase (serverless PostgreSQL) stores durable application state including sessions, canvases, and widget specifications. An async workflow layer uses Amazon DynamoDB for job tracking, Amazon SNS and SQS for notifications, and Amazon API Gateway WebSocket push to update the UI in real time during long-running analytics tasks.

Claude runs as a Strands-based agent that supports streaming responses and tool calling; users can invoke the same workflows manually that Clara calls through Strands tools. Streaming is central to the experience: a custom merge layer sits between the Strands async stream and Server-Sent Event output, handling heartbeats to keep connections alive, text buffering with word-boundary-aware flushing to prevent UI flicker, and interleaving real-time canvas update events into the stream. Clara uses AgentCore memory with three strategies—semantic facts (organizational context like account structures), user preferences (layout choices, default aggregations, chart types), and canvas summaries (analytical thread across sessions)—so it learns how each user engages with their data over time. Sessions are scoped by canvas, not ephemeral HTTP session, so conversation context persists across browser refreshes. For tenant isolation, Amazon Bedrock Guardrails runs as a pre-check on raw user prompts, enforcing cross-tenant data access policies and prompt-attack detection, while a tenant policy layer sanitizes outbound stream chunks and widget events.

The outcome has been dramatic. Development velocity jumped: time-to-production dropped from 10–12 months to 4 months after replacing the self-managed Amazon EKS stack with a single managed service. The new runtime now serves 4–6 production-ready agents across a shared architecture. By restructuring Clara around Amazon Bedrock AgentCore and a Lakehouse-first analytics model, nOps established a more scalable foundation for AI-powered FinOps workflows while freeing engineering resources for product innovation rather than infrastructure maintenance.

Context & Analysis

nOps faced a structural problem common to fast-growing AI products: the infrastructure chosen for rapid initial delivery became a bottleneck. The original Clara agent, built on Kubernetes, LangChain, and web APIs, suffered from long context windows that increased latency, multiple orchestration layers that made debugging harder, and a data path that tied answers to API responses rather than analytics semantics. As the product grew and the customer base expanded, engineering time increasingly went into maintaining infrastructure rather than building features.

The shift to Amazon Bedrock AgentCore resolved these constraints by offering a managed, purpose-built runtime for agents. By pairing AgentCore with Databricks Lakehouse Metric Views—a governed semantic layer that pre-models business logic like "True Customer Cost"—nOps eliminated the need to recalculate financial logic on every query. The addition of Databricks Lakebase (a serverless PostgreSQL layer) for storing sessions, canvases, and widget specifications meant that insights generated in chat could become persistent, shareable artifacts. This architectural change directly enabled the 75% reduction in time-to-production: one managed service replaced multiple non-purpose-built layers, and the team could focus on domain logic instead of infrastructure glue.

The async workflow layer—using DynamoDB, SNS, SQS, and WebSocket push—ensures the user experience remains responsive during heavy analytics processing, with real-time UI updates. Memory strategies (semantic facts, user preferences, canvas summaries) scoped by canvas rather than ephemeral HTTP session allow Clara to learn how each user engages with their data and maintain context across browser refreshes. Tenant isolation is enforced via Amazon Bedrock Guardrails as a pre-check on raw prompts, plus a tenant policy layer that sanitizes outbound data.

FAQ

How much faster is development now?
Time-to-production fell from 10–12 months to 4 months after moving from self-managed Amazon EKS to Amazon Bedrock AgentCore.
What is nOps and who does it serve?
nOps is an AI-powered cloud optimization solution that helps teams manage commitment optimization (such as Reserved Instances and AWS Savings Plans) across AWS, Google Cloud, and Microsoft Azure. The company currently supports customers representing more than USD $4 billion in cloud spend under management.
How many agents can the new system run?
The new architecture supports 4–6 production-ready agents serving analytics across a single shared runtime.
Amazon AI BlogRead Original Article

Get the latest Large Language Models news every morning

AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.

Free · takes 30 seconds · unsubscribe anytime

Ask AI

Ask AI anything about this article. Q&As are published on this page for other readers too.

Related Articles

Next articleSuper Micro's $60B Orders vs. Softer Revenue in Earnings Test

The AI news that matters, in one minute each morning.

Sign up free