Building a Bot Factory: Standardizing AI Agent Development with Multi-Agent Architecture

autoscout24 · Automotive · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Enterprise agent platform engineering

AutoScout24 needed to move from fragmented generative-AI experiments to a standardized, secure, reusable way for teams to build and operate AI agents, starting with a developer-support bot that reduced repetitive support load.

Constraints:

• platform engineers were spending up to 30% of time on repetitive support tasks
• agents need both knowledge retrieval and action execution
• Slack interactions require secure ingress and session isolation
• agent contexts must not leak across Slack threads
• teams need reusable infrastructure rather than one-off prototypes

Architecture

AutoScout24 built a serverless Bot Factory blueprint on AWS. Slack messages enter through API Gateway and Lambda, are queued in SQS, and invoke an Amazon Bedrock AgentCore runtime. A Strands-based orchestrator agent delegates to specialized agents such as a Knowledge Base agent for RAG and a GitHub agent for actions like assigning Copilot licenses. AgentCore supplies session isolation, scaling, security, and observability.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  slack-user-interaction[Slack user interaction] --> api-gateway-lambda-ingress[API Gateway Lambda ingress]
  api-gateway-lambda-ingress --> sqs-queue[SQS queue]
  sqs-queue --> agentcore-runtime[AgentCore runtime]
  agentcore-runtime --> strands-orchestrator-agent[Strands orchestrator agent]
  agentcore-runtime --> x-ray-tracing[X-Ray tracing]
  strands-orchestrator-agent --> knowledge-base-agent[Knowledge Base agent]
  strands-orchestrator-agent --> github-agent[GitHub agent]

Components

Data flow

A developer posts in Slack. API Gateway and Lambda verify the Slack signature, SQS buffers the event, a Lambda invocation activates AgentCore, and the Strands orchestrator routes the prompt to a Knowledge Base agent or GitHub action agent. AgentCore keeps per-thread session context and X-Ray traces the path through tool calls and the final Slack response.

Why this architecture

The Bot Factory separates reusable infrastructure from business-specific agent logic. AgentCore handles isolation, scaling, session state, security, and observability, while Strands makes worker agents callable tools so AutoScout24 can add new agents without rebuilding the platform.

Models used: Amazon Bedrock foundation models · Strands Agents · Amazon Bedrock Knowledge Bases

Scale

• AutoScout24 is described as Europe's leading automotive marketplace across several European countries.
  “Europe’s leading automotive marketplace platform that connects buyers and sellers of new and used cars, motorcycles, and commercial vehicles across several European countries.”article, stated
• Platform engineers were spending up to 30 percent of time on repetitive support tasks.
  “AutoScout24 AI Platform engineers were spending up to 30% of their time on repetitive tasks like answering questions, granting access to tools”article, stated
• The initial strategy was created in a three-week AWS PACE AI bootcamp.
  “The AutoScout24 AI Platform Engineering team partnered with the AWS Prototype and Cloud Engineering (PACE) team in a three-week AI bootcamp.”article, stated

Alternatives considered (roads not taken)

Fragmented team-level experiments

Rejected because: AutoScout24 wanted a paved path for secure, scalable, maintainable agents across the organization.

Monolithic agent with all task logic inside one controller

Rejected because: The orchestrator delegates to specialized agents to preserve separation of concerns and extensibility.

Patterns

multi-agent-orchestration (agent-design)

A central orchestrator delegates to specialized Knowledge Base and GitHub agents.

rag-retrieval (retrieval)

The Knowledge Base agent answers how-to questions from internal documentation.

observability-tracing (operations)

AWS X-Ray traces Slack ingress, SQS, orchestrator processing, foundation model calls, tool invocations, and response.

privacy-preserving-processing (security)

AgentCore session isolation and IAM least privilege help prevent data leakage across threads and tools.

Tradeoffs

Agent architecture

Chose orchestrator plus specialized worker agents over single agent containing every task.

Rationale: Specialization makes new capabilities easier to add without rearchitecting.

Model selection per task

Chose mix powerful and lighter foundation models over one model for every worker.

Rationale: Complex reasoning and routine workflows have different cost, performance, and accuracy needs.

Gotchas (what bit them)

Slack conversation context can leak or mix if sessions are not isolated.

Root cause: Multiple Slack threads can invoke the same agent platform.

Resolution: Generate a deterministic sessionId per Slack thread and let AgentCore isolate per-session resources.

One-off agents force teams to reinvent infrastructure.

Root cause: Fragmented experiments lack shared session, security, observability, and scaling patterns.

Resolution: Create a reusable Bot Factory blueprint.

Evaluation

The article reports production readiness, active Slack support-bot deployment, reduced manual support load, session isolation, X-Ray traceability, and reusable blueprint outcomes.

Metrics: 30% platform-engineer support time · production-ready Slack bot · per-thread session isolation · X-Ray traces

Outcomes

• AutoScout24 deployed a production-ready Slack support bot.
• The Bot Factory created a reusable architecture teams can start from.
• Domain experts can plug new tools or specialized agents into the factory.

The initial use case targeted a 30 percent support-time tax on AI Platform engineers and produced a reusable enterprise-agent blueprint.