KTern.AI が Amazon Bedrock AgentCore を活用し、SAP 向けエージェント AI を構築した方法

In this post, learn how KTern.AI, an SAP digital transformation platform, used Amazon Bedrock AgentCore to build and deploy AI agents ready for enterprise-scale SAP transformation workloads. These agents autonomously orchestrate workflows from reverse engineering, fit-to-standard, and code analysis to exception mining in Finance and Sales processes. The result is automation without custom agent infrastructure.

SAP digital transformations are among the most complex, high-stakes initiatives an enterprise can undertake. They span months or years, involve intricate interdependencies across business processes and custom code, and demand domain expertise that is hard to scale with human consultants alone. At KTern.AI, we have spent years building a system that makes these transformations faster and more predictable. Our move to agentic AI is the most significant leap in that mission to date.

Evolving from a traditional software as a service (SaaS) platform into a next-generation agentic AI platform meant orchestrating multiple specialized agents across long-running enterprise programs. Each agent operates with persistent context, secure tool access, and production-grade reliability. We built that system on Amazon Bedrock AgentCore using the Strands Agents SDK. This post walks through how we architected it, which agents we built, and the outcomes for our customers.

Overview of KTern.AI

KTern.AI is an SAP Spotlight Partner and SAP-certified Digital Transformation as a Service (DXaaS) platform. It accelerates SAP S/4HANA migrations, system conversions, and digital transformation programs across five automation streams: Digital Maps, Digital Projects, Digital Process, Digital Labs, and Digital Mines. A proprietary institutional knowledge intelligence engine encodes years of SAP transformation patterns and best practices into the system, and combined with data-driven hyperautomation it delivers 7x faster transformations with a 24 percent reduction in overall effort.

The challenge

As KTern.AI’s platform matured, truly autonomous SAP transformation required more than single-turn AI interactions. Agents had to reason across projects spanning months or years, coordinate across multiple domains at once, and operate within strict enterprise security and compliance boundaries.

Several interlocking challenges no patchwork of custom infrastructure could cleanly solve stood in the way:

• Persistent context at scale. Agents needed to retain state across hundreds of interactions, reference historical decisions, and build cumulative context over the full project lifecycle, not reset with every session. The goal is the right context rather than all of it. Overloading an agent with excess context slows it down, raises cost, and increases the chance of hallucination.

• Secure, governed tool integration. Real-time access to SAP APIs, customer enterprise resource planning (ERP) systems, process repositories, and KTern.AI data stores required authenticated, auditable connections that enterprise security teams could stand behind.

• Multi-tenancy and configuration-driven flexibility. Each customer runs as an isolated tenant with its own processes, exceptions, and business rules. Agents had to be configurable per tenant without engineering writing custom code for every deployment.

• Dynamic scalability. A rapid SAP assessment might engage a handful of agents for a few hours. A full enterprise migration runs dozens of agents continuously over months.

• Production-grade observability. Debugging multi-agent workflows without detailed logs, traces, and metrics in enterprise environments isn’t viable. Every agent decision and tool invocation needed to be traceable.

Before AgentCore, the application ran on a self-managed container stack we built and operated ourselves. It worked, but it consumed engineering time on infrastructure that had nothing to do with our core differentiation: designing agents that understand SAP transformation.

Solution overview

We built KTern.AI’s agentic AI platform on Amazon Bedrock AgentCore using the Strands Agents SDK. The core principle is a clean separation of concerns: SAP domain intelligence lives in KTern.AI’s layer, while every infrastructure concern (hosting, scaling, memory, tool access, identity, and observability) is delegated to AgentCore.

Every agent deploys through configuration with zero custom orchestration code. Each agent’s behavior is defined by its prompt, tool bindings, and orchestration pattern. A new agent reaches production in 4-6 hours, with no infrastructure provisioning or pipeline engineering. We use Strands multi-agent patterns by workload: swarm for parallel discovery, workflow for sequential phases, and graph for conditional pipelines.

Architecture

*Figure 1. KTern.AI’s agentic AI architecture on Amazon Bedrock AgentCore.*

The architecture flows from the client layer inward. Enterprise users submit transformation requests through the KTern.AI platform. Those requests route to the agent orchestration layer, where specialized agents run on AgentCore runtime with full session isolation, so one customer’s context isn’t accessible to another. Each agent invokes external tools through the AgentCore gateway Model Context Protocol (MCP) layer, which manages authenticated connections to SAP APIs, customer ERP systems, and KTern.AI’s repositories. Agents reach Amazon Bedrock and AgentCore privately over virtual private cloud (VPC) interface endpoints powered by AWS PrivateLink, so traffic stays off the public internet.

As agents are invoked, AgentCore memory retrieves and updates persistent context tied to the project, preserving process decisions, code patterns, and accumulated insights across sessions. AgentCore identity enforces authentication and least-privilege access for agents and tools. Every action and model response is captured by AgentCore observability and sent as logs, metrics, and traces to Amazon CloudWatch. At the foundation, Amazon Bedrock provides model access, including Anthropic’s Claude family of models. Amazon Simple Storage Service (Amazon S3), AWS Lambda, and AWS Identity and Access Management (IAM) support the broader system.

Results and outcomes

The shift to an agentic AI platform on Amazon Bedrock AgentCore changed what’s possible for KTern.AI’s customers. In production, KTern.AI’s agents cut overall SAP project timelines by 45 percent and reduced discovery and assessment time by 60–70 percent. They also surface 90 percent of Finance and Sales operational exceptions autonomously and reclaimed 480 engineering hours per month. SAP transformations that once required large consultant teams and months of manual analysis are now substantially automated. These figures reflect KTern.AI’s internal measurements across its production SAP transformation engagements.

Development velocity

Before AgentCore, building a new agent capability meant assembling custom infrastructure for orchestration, memory, tool access, identity, and monitoring, a minimum of 2–3 weeks per agent. The configuration-driven approach removed that overhead.

• First production agent deployed in 4–6 hours, configuration-only, with zero lines of custom orchestration code. That’s an 85 percent reduction in development cycle.

• Infrastructure setup time reduced by 95 percent: no provisioning, no custom pipeline engineering.

• New agents ship to production same-day through configuration deployment.

Operational efficiency

With infrastructure managed by AWS, the operations posture improved while costs fell.

• 99.8 percent agent uptime sustained across production deployments.

• 70 percent reduction in infrastructure costs versus the self-managed container stack we previously operated.

• 480 engineering hours per month reclaimed (equivalent to three full-time engineers), all reinvested in agent intelligence and new capabilities.

SAP transformation impact

The compounding value of agentic automation is clearest in customer outcomes.

• 45 percent average reduction in overall SAP project timelines.

• 60–70 percent reduction in discovery and assessment time, the phase that historically consumed the largest share of early project budget.

• Up to 60 percent reduction in manual subject matter expert (SME) and consultant dependency during analysis phases.

• 82 percent first-pass success rate on automatically generated test cases.

• 90 percent of operational exceptions in Finance and Sales modules autonomously identified by exception mining agents.

• 40 percent reduction in post-go-live support incidents driven by earlier, more comprehensive risk identification.

Risk reduction and quality

Speed gains matter only when quality holds. Agentic AI improved the consistency and reliability of the transformations KTern.AI supports.

• Reverse engineering and custom code analysis agents surface technical debt and migration risk early, before it compounds into expensive downstream problems.

• Standardized agent-driven approaches reduce quality variance across projects, independent of which consultant team is engaged.

• Centralized prompt management provides version control, rollback, and consistent governance across agent deployments.

• Configuration-driven testing of agent configurations, orchestration patterns, and model selections supports continuous improvement without deployment overhead.

Amazon Bedrock AgentCore components

KTern.AI’s platform uses six AgentCore capabilities. AgentCore runtime hosts the agents, AgentCore memory preserves project context, AgentCore gateway connects tools, AgentCore identity governs access, AgentCore observability traces behavior, and AgentCore evaluations measures quality. The sections that follow describe how KTern.AI uses each one.

AgentCore runtime

Deploying our first production agent took 4–6 hours, with zero infrastructure code. AgentCore runtime handled compute provisioning, scaling, and session isolation across simultaneous customer environments. Multi-tenant isolation came built in, not something we had to design, implement, and audit ourselves.

AgentCore memory

SAP transformation projects run 12–18 months across discovery, design, testing, and cutover, with hundreds of agent interactions. AgentCore memory let our agents retain project context across them, including custom code inventories, process decisions, and exception patterns, with no memory infrastructure to build. Agents carry full project history into every interaction rather than starting from scratch.

AgentCore gateway (MCP)

KTern.AI’s agents need real-time access to live SAP environments, customer ERP APIs, process mining sources, and analytical repositories, and that list grows with every customer. The AgentCore gateway implementation of MCP let us register new tools through configuration rather than custom integration code. Exception mining agents reach Finance and Sales data directly in customer systems through the gateway.

AgentCore identity

Enterprise security teams scrutinize every system that touches their SAP landscape. AgentCore identity gave us least-privilege access per agent, full audit trails of tool invocations, and compatibility with customers’ existing identity infrastructure. That gave security teams the confidence to approve agents for production without custom access-control work from us.

AgentCore observability

Before AgentCore observability with Amazon CloudWatch and OpenTelemetry, debugging a multi-step agent failure meant correlating logs across disconnected systems by hand. Today we trace issues from the initial request through every agent decision and tool call to the final response in minutes. That visibility underpins our 99.8 percent agent uptime.

AgentCore evaluations

Quality consistency was an early concern, especially for the test case generation agent where accuracy affects go-live risk. Rather than build evaluation harnesses per agent, we run cycles using AgentCore evaluations with KTern.AI-specific SAP test cases. Evaluating on every configuration change, not only at launch, sustains an 82 percent first-pass success rate and flags model-driven behavior shifts early.

KTern.AI’s agent network

KTern.AI operates over 20 specialized agents in production, each owning a discrete domain of the SAP transformation lifecycle. They’re built through configuration, with behavior defined by prompts, tool bindings, and orchestration patterns. As of this writing we maintain over 50 agent configurations across customer scenarios. The core agents driving these outcomes follow.

Reverse engineering agent

The reverse engineering agent performs deep automated analysis of a customer’s existing SAP landscape, scanning custom ABAP code, user exits, enhancements, configurations, and process variants to build a current-state inventory. Work that once took consultants weeks now completes in a fraction of the time. Its output feeds downstream agents as a shared foundation for reasoning about migration impact and modernization paths.

Forward engineering agent

After the current state is mapped, the forward engineering agent converts those insights into clean-core-aligned target architectures, standard integration patterns, and migration-ready code. It applies clean-core principles (keep only standard functionality in the digital core, externalize extensions) to recommend what to retain, refactor, or retire. Together the two agents form a continuous reverse-to-forward pipeline that cuts design and blueprinting effort on S/4HANA migrations.

Fit-to-standard agent

The fit-to-standard agent evaluates a customer’s business processes against SAP standard processes, identifying where customizations diverge and recommending alternatives. This is one of the most consultant-intensive activities in any transformation, normally requiring functional consultants to review hundreds of processes by hand. The agent automates that analysis at scale, with up to 60 percent reduction in the SME time this phase requires.

Custom code analysis agent

Custom ABAP code is one of the biggest risk factors in any S/4HANA migration. The custom code analysis agent assesses the full landscape for migration compatibility, deprecated API usage, performance risk, and modernization potential. It then classifies each object by complexity with prioritized remediation guidance. This early visibility is a primary driver of the 40 percent reduction in post-go-live support incidents across engagements.

Test case generation agent

Testing is one of the most resource-intensive phases of SAP transformation. The test case generation agent automates executable test cases from business process flows, custom code analysis outputs, and configuration data. It produces scripts with test data, expected outcomes, and validation criteria at a coverage manual authoring cannot match. It achieves an 82 percent first-pass execution success rate.

Process mining agent

The process mining agent analyzes SAP event logs (purchase-to-pay, order-to-cash, record-to-report, and others) to surface how processes actually run versus how they are designed. It identifies deviations, bottlenecks, rework loops, and automation opportunities invisible in static documentation, providing evidence to prioritize redesign mid-transformation and continuous health monitoring post-go-live.

Exception mining agent

Operational exceptions in Finance and Sales (unmatched invoices, blocked purchase orders, open credit memos, billing exceptions) are usually found reactively. The exception mining agent proactively identifies and classifies them across FI, CO, SD, and MM modules. In production, 90 percent of these exceptions are now surfaced autonomously, cutting manual effort and supporting resolution before business impact.

Lessons learned

Building over 20 production agents on Amazon Bedrock AgentCore sharpened our view of what it takes to build agentic AI reliably for enterprise use cases. For other independent software vendors (ISVs) and SaaS builders, these lessons shaped our approach most.

• Start with configuration, not code. Each time we were tempted to write custom orchestration logic, a configuration-based equivalent proved faster to build and easier to maintain. Staying configuration-driven is what compressed per-agent deployment from weeks to hours.

• Memory architecture is a first-class design decision. In long-running enterprise workflows, memory schema design determines whether agents reason like experienced consultants or start from scratch every session. This is context engineering: bringing enough context for the agent to reason well, without overloading it. Design memory before writing the first prompt.

Instrument from day one. Multi-agent systems fail in ways that are invisible without distributed tracing, so observability from the first deployment turns hours of debugging into minutes, and the