How AutoScout24 constructed a Bot Manufacturing unit to standardize AI agent growth with Amazon Bedrock

AutoScout24 is Europe’s main automotive market platform that connects consumers and sellers of recent and used automobiles, bikes, and business automobiles throughout a number of European nations. Their long-term imaginative and prescient is to construct a Bot Manufacturing unit, a centralized framework for creating and deploying synthetic intelligence (AI) brokers that may carry out duties and make selections inside workflows, to considerably enhance operational effectivity throughout their group.

From disparate experiments to a standardized framework

As generative AI brokers (methods that may purpose, plan, and act) change into extra highly effective, the chance to enhance inner productiveness for AutoScout24 was clear. This led to varied engineering groups experimenting with the know-how. As AI innovation accelerated throughout AutoScout24, they acknowledged a chance to pioneer a standardized strategy for AI growth. Whereas AutoScout24 had efficiently experimented with varied instruments and frameworks on Amazon Net Providers (AWS), they envisioned making a unified, enterprise-grade framework that would allow sooner innovation. Their purpose was to determine a paved path that would make it simpler for groups throughout the group to construct safe, scalable, and maintainable AI brokers. The AutoScout24 AI Platform Engineering group partnered with the AWS Prototype and Cloud Engineering (PACE) group in a three-week AI bootcamp. The purpose was to maneuver from fragmented experiments to a coherent technique by making a reusable blueprint, a Bot Manufacturing unit, to standardize how future AI brokers are constructed and operated inside their firm.

The problem: figuring out a high-impact use case

To floor the Bot Manufacturing unit blueprint in a tangible enterprise case, the group focused a major operational price: inner developer help. The issue was well-defined. AutoScout24 AI Platform engineers have been spending as much as 30% of their time on repetitive duties like answering questions, granting entry to instruments, and finding documentation. This help tax lowered total productiveness. It diverted expert engineers from high-priority characteristic growth and compelled different builders to attend for routine requests to be accomplished. An automatic help bot was an excellent first use case as a result of it wanted to carry out two core agent capabilities:

1. Data retrieval: Answering “how-to” questions by looking out inner documentation, a functionality generally known as Retrieval Augmented Era (RAG).
2. Motion execution: Performing duties in different methods, resembling assigning a GitHub Copilot license, which requires safe API integration, or “device use.”

By constructing a bot that would do each, the group might validate the blueprint whereas delivering instant enterprise worth.

Architectural overview

On this publish, we discover the structure that AutoScout24 used to construct their standardized AI growth framework, enabling fast deployment of safe and scalable AI brokers.

The structure is designed with a easy, decoupled circulate to verify the system is each resilient and simple to keep up. The diagram supplies a simplified view centered on the core generative-AI workflow. In a manufacturing setting, further AWS companies resembling AWS Id and Entry Administration (IAM), Amazon CloudWatch, AWS X-Ray, AWS CloudTrail, AWS Net Software Firewall (WAF), and AWS Key Administration Service (KMS) could possibly be built-in to boost safety, observability, and operational governance.

Right here is how a request flows by way of the system:

1. Consumer interplay by way of Slack: A developer posts a message in a help channel, for instance, “@SupportBot, can I get a GitHub Copilot license?“
2. Safe ingress by way of Amazon API Gateway & AWS Lambda: Slack sends the occasion to an Amazon API Gateway endpoint, which triggers an AWS Lambda perform. This perform performs a necessary safety verify, verifying the request’s cryptographic signature to substantiate it’s authentically from Slack.
3. Decoupling by way of Amazon Easy Queue Service (SQS): The verified request is positioned onto an Amazon SQS First-In, First-Out (FIFO) queue. This decouples the front-end from the agent, enhancing resilience. Utilizing a FIFO queue with the message’s thread timestamp because the MessageGroupId makes positive that replies inside a single dialog are processed so as, which is necessary for sustaining coherent conversations.
4. Agent execution by way of Amazon Bedrock AgentCore: The SQS queue triggers a Lambda perform when messages arrive, which prompts the agent operating within the AgentCore Runtime. AgentCore manages the operational duties, together with orchestrating calls to the muse mannequin and the agent’s instruments. The Orchestrator Agent’s logic, constructed with Strands Brokers, analyzes the consumer’s immediate and determines the proper specialised agent to invoke—both the Data Base Agent for a query or the GitHub Agent for an motion request.

A vital implementation element is how the system leverages AgentCore’s full session isolation. To keep up conversational context, the system generates a novel, deterministic sessionId for every Slack thread by combining the channel ID and the thread’s timestamp. This sessionId is handed with each agent invocation inside that thread. Interactions in a thread share this identical sessionId, so the agent treats them as one steady dialog. In the meantime, interactions in different threads get totally different sessionIds, preserving their contexts separate. In impact, every dialog runs in an remoted session: AgentCore spins up separate assets per sessionId, so context and state don’t leak between threads. In apply, which means that if a developer sends a number of messages in a single Slack thread, the agent remembers the sooner components of that dialog. Every thread’s historical past is preserved mechanically by AgentCore.

This session administration technique can be important for observability. Based mostly on a novel sessionId, the interplay might be traced utilizing AWS X-Ray, which presents perception into the circulate – from the Slack message arriving at API Gateway to the message being enqueued in SQS. It follows the orchestrator’s processing, the decision to the muse mannequin, subsequent device invocations (resembling a knowledge-base lookup or a GitHub API name), and at last the response again to Slack.

Metadata and timing assist point out the circulate of every step to grasp the place time is spent. If a step fails or is gradual (for instance, a timeout on an exterior API name), X-Ray pinpoints which step induced the problem. That is invaluable for diagnosing issues rapidly and constructing confidence within the system’s habits.

The answer: A reusable blueprint powered by AWS

The Bot Manufacturing unit structure designed by the AutoScout24 and AWS groups is event-driven, serverless, and constructed on a basis of managed AWS companies. This strategy supplies a resilient and scalable sample that may be tailored for brand new use circumstances.

The answer builds on Amazon Bedrock and its built-in capabilities:

• Amazon Bedrock supplies entry to high-performing basis fashions (FMs), which act because the reasoning engine for the agent.
• Amazon Bedrock Data Bases permits the RAG functionality, permitting the agent to hook up with AutoScout24’s inner documentation and retrieve info to reply questions precisely.
• Amazon Bedrock AgentCore is a key element of the operational aspect of the blueprint. It supplies the totally managed, serverless runtime setting to deploy, function, and scale the brokers.

This answer supplies a major benefit for AutoScout24. As an alternative of constructing foundational infrastructure for session administration, safety, and observability, they use AgentCore’s purpose-built companies. This enables the group to give attention to the agent’s enterprise logic quite than the underlying infrastructure. AgentCore additionally supplies built-in safety and isolation options. Every agent invocation runs in its personal remoted container, serving to to forestall knowledge leakage between periods. Brokers are assigned particular IAM roles to limit their AWS permissions (following the precept of least privilege). Credentials or tokens wanted by agent instruments (resembling a GitHub API key) are saved securely in AWS Secrets and techniques Supervisor and accessed at runtime. These options give the group a safe setting for operating brokers with minimal customized infrastructure.

The agent itself was constructed utilizing the Strands Brokers SDK, an open-source framework that simplifies defining an agent’s logic, instruments, and habits in Python. This mixture proves efficient: Strands to construct the agent, and AgentCore to securely run it at scale. The group adopted a classy “agents-as-tools” design sample, the place a central orchestrator Agent acts as the principle controller. This orchestrator doesn’t include the logic for each doable job. As an alternative, it intelligently delegates requests to specialised, single-purpose brokers. For the help bot, this included a Data Base agent for dealing with informational queries and a GitHub agent for executing actions like assigning licenses. This modular design makes it simple to increase the system with new capabilities, resembling including a PR overview agent with out re-architecting your entire pipeline. Working these brokers on Amazon Bedrock additional enhances flexibility, because the group can select from a broad vary of basis fashions. Extra highly effective fashions might be utilized to complicated reasoning duties, whereas lighter, cost-efficient fashions are well-suited for routine employee brokers resembling GitHub license requests or operational workflows. This means to combine and match fashions permits Autoscout24 to stability price, efficiency, and accuracy throughout their agent structure.

Orchestrator agent: constructed with Strands SDK

Utilizing the Strands Brokers SDK helped the group to outline the orchestrator agent with concise, declarative code. The framework makes use of a model-driven strategy, the place the developer focuses on defining the agent’s directions and instruments, and the muse mannequin handles the reasoning and planning. The orchestrator agent might be expressed in only a few dozen traces of Python. The instance snippet beneath (simplified for readability, not supposed for direct use) reveals how the agent is configured with a mannequin, a system immediate, and a listing of instruments (which on this structure symbolize the specialised brokers):

# A simplified, consultant instance of the orchestrator agent logic
# constructed with the Strands Brokers SDK and deployed on Amazon Bedrock AgentCore.
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent
from strands.fashions import BedrockModel
from instruments import knowledge_base_query_tool, github_copilot_seat_agent
# Initialize the AgentCore utility, which acts because the serverless container
app = BedrockAgentCoreApp()
class OrchestratorAgent:
    def __init__(self):
        # 1. Outline the Mannequin: Level to a basis mannequin in Amazon Bedrock.
        self.mannequin = BedrockModel(model_id="anthropic.claude-3-sonnet-20240229-v1:0")
        
        # 2. Outline the Immediate: Give the agent its core directions.
        self.system_prompt = """
        You're a useful and pleasant help bot for the AutoScout24 Platform Engineering group.
        Your purpose is to reply developer questions and automate widespread requests.
        Use your instruments to reply questions or carry out actions.
        If you happen to can not deal with a request, politely say so.
        """
        
        # 3. Outline the Instruments: Present the agent with its capabilities.
        # These instruments are entry factors to different specialised Strands brokers.
        self.instruments = [
            knowledge_base_query_tool, 
            github_copilot_seat_agent
        ]
        
        # Create the agent occasion
        self.agent = Agent(
            mannequin=self.mannequin, 
            system_prompt=self.system_prompt, 
            instruments=self.instruments
        )
    def __call__(self, user_input: str):
        # Run the agent to get a response for the consumer's enter
        return self.agent(user_input)
# Outline the entry level that AgentCore will invoke when a brand new occasion arrives from SQS
@app.entrypoint
def foremost(occasion):
    # Extract the consumer's question from the incoming occasion
    user_query = occasion.get("immediate")
    
    # Instantiate and run the orchestrator agent
    return OrchestratorAgent()(user_query)

One other instance is the GitHub Copilot license agent. It’s applied as a Strands device perform. The next snippet reveals how the group outlined it utilizing the @device decorator. This perform creates a GitHubCopilotSeatAgent, passes the consumer’s request (a GitHub username) to it, and returns the outcome:

from strands import Agent, device
class GitHubCopilotSeatAgent:
def __call__(self, question: str):
agent = Agent(mannequin=self.mannequin, system_prompt=self.system_prompt, instruments=self.instruments)
return agent(question)

@device
def github_copilot_seat_agent(github_username: str) -> str:
agent = GitHubCopilotSeatAgent() response = agent(f"Request GitHub Copilot license for consumer: {github_username}")
return str(response)

Key advantages of this strategy embrace clear separation of issues. The developer writes declarative code centered on the agent’s function. The complicated infrastructure logic, together with scaling, session administration, and safe execution, is dealt with by Amazon Bedrock AgentCore. This abstraction permits fast growth and allowed AutoScout24 to maneuver from prototype to manufacturing extra rapidly. The instruments checklist successfully makes different brokers callable capabilities, permitting the orchestrator to delegate duties with no need to know their inner implementation.

The influence: A validated blueprint for enterprise AI

The Bot Manufacturing unit challenge delivers outcomes that prolonged past the preliminary prototype. It creates instant enterprise worth and establishes a strategic basis for future AI innovation at AutoScout24.The important thing outcomes have been:

• A production-ready help bot: The group deployed a purposeful Slack bot that’s actively lowering the handbook help load on the AutoScout24 AI Platform Engineering Group, addressing the 30% of time beforehand spent on repetitive duties.
• A reusable Bot Manufacturing unit blueprint: The challenge produces a validated, reusable architectural sample. Now, groups at AutoScout24 can construct a brand new agent by beginning with this confirmed template (Slack -> API Gateway -> SQS -> AgentCore). This considerably accelerates innovation by permitting groups to give attention to their distinctive enterprise logic, not on reinventing the infrastructure. This modular design additionally prepares them for extra superior multi-agent collaboration, probably utilizing requirements just like the Agent-to-Agent (A2A) protocol as their wants evolve.
• Enabling broader AI growth: By abstracting away the infrastructure complexity, the Bot Manufacturing unit empowers extra folks to construct AI options. A website professional in safety or knowledge analytics can now create a brand new device or specialised agent and “plug it in” to the manufacturing unit with no need to be an professional in distributed methods.

Conclusion: A brand new mannequin for enterprise brokers

AutoScout24’s partnership with AWS turned fragmented generative AI experiments right into a scalable, standardized framework. By adopting Amazon Bedrock AgentCore, the group moved their help bot from prototype to manufacturing, whereas specializing in their Bot Manufacturing unit imaginative and prescient. AgentCore manages session state and scaling, so engineers can give attention to high-value enterprise logic as a substitute of infrastructure. The end result is greater than a help bot: it’s a reusable basis for constructing enterprise brokers. With AgentCore, AutoScout24 can transfer from prototype to manufacturing effectively, setting a mannequin for a way organizations can standardize generative AI growth on AWS. To start out constructing enterprise brokers with Amazon Bedrock, discover the next assets:

In regards to the authors

Andrew Shved is a Senior AWS Prototyping Architect who leads groups and clients in constructing and delivery Generative AI–pushed options, from early prototypes to manufacturing on AWS.

Muhammad Uzair Aslam is a tenured Technical Program Supervisor on the AWS Prototyping group, the place he works intently with clients to speed up their cloud and AI journeys. He thrives on diving deep into technical particulars and turning complexity into impactful, value-driven options.

Arslan Mehboob is a Platform Engineer and AWS-certified options architect with deep experience in cloud infrastructure, scalable methods, and software program engineering. He at present builds resilient cloud platforms and is obsessed with AI and rising applied sciences.

Vadim Shiianov is a Information Scientist specializing in machine studying and AI-driven methods for real-world enterprise functions. He works on designing and deploying ML and Generative AI options that translate complicated knowledge into measurable influence. He’s obsessed with rising applied sciences and constructing sensible, scalable methods round them.