Construct agentic programs with CrewAI and Amazon Bedrock

This put up is co-authored with Joao Moura and Tony Kipkemboi from CrewAI.

The enterprise AI panorama is present process a seismic shift as agentic programs transition from experimental instruments to mission-critical enterprise property. In 2025, AI brokers are anticipated to develop into integral to enterprise operations, with Deloitte predicting that 25% of enterprises utilizing generative AI will deploy AI brokers, rising to 50% by 2027. The world AI agent house is projected to surge from $5.1 billion in 2024 to $47.1 billion by 2030, reflecting the transformative potential of those applied sciences.

On this put up, we discover how CrewAI’s open supply agentic framework, mixed with Amazon Bedrock, permits the creation of subtle multi-agent programs that may remodel how companies function. By way of sensible examples and implementation particulars, we exhibit how one can construct, deploy, and orchestrate AI brokers that may sort out advanced duties with minimal human oversight. Though “brokers” is the buzzword of 2025, it’s vital to know what an AI agent is and the place deploying an agentic system might yield advantages.

Agentic design

An AI agent is an autonomous, clever system that makes use of giant language fashions (LLMs) and different AI capabilities to carry out advanced duties with minimal human oversight. Not like conventional software program, which follows pre-defined guidelines, AI brokers can function independently, study from their atmosphere, adapt to altering situations, and make contextual choices. They’re designed with modular parts, corresponding to reasoning engines, reminiscence, cognitive abilities, and instruments, that allow them to execute subtle workflows. Conventional SaaS options are designed for horizontal scalability and common applicability, which makes them appropriate for managing repetitive duties throughout numerous sectors, however they usually lack domain-specific intelligence and the pliability to handle distinctive challenges in dynamic environments. Agentic programs, alternatively, are designed to bridge this hole by combining the pliability of context-aware programs with area information. Think about a software program improvement use case AI brokers can generate, consider, and enhance code, shifting software program engineers’ focus from routine coding to extra advanced design challenges. For instance, for the CrewAI git repository, pull requests are evaluated by a set of CrewAI brokers who overview code primarily based on code documentation, consistency of implementation, and safety issues. One other use case will be seen in provide chain administration, the place conventional stock programs would possibly monitor inventory ranges, however lack the aptitude to anticipate provide chain disruptions or optimize procurement primarily based on trade insights. In distinction, an agentic system can use real-time information (corresponding to climate or geopolitical dangers) to proactively reroute provide chains and reallocate sources. The next illustration describes the parts of an agentic AI system:

Overview of CrewAI

CrewAI is an enterprise suite that features a Python-based open supply framework. It simplifies the creation and administration of AI automations utilizing both AI flows, multi-agent programs, or a mixture of each, enabling brokers to work collectively seamlessly, tackling advanced duties by way of collaborative intelligence. The next determine illustrates the aptitude of CrewAI’s enterprise providing:

CrewAI’s design facilities across the capacity to construct AI automation by way of flows and crews of AI brokers. It excels on the relationship between brokers and duties, the place every agent has an outlined position, aim, and backstory, and may entry particular instruments to perform their aims. This framework permits for autonomous inter-agent delegation, the place brokers can delegate duties and inquire amongst themselves, enhancing problem-solving effectivity. This development is fueled by the growing demand for clever automation and personalised buyer experiences throughout sectors like healthcare, finance, and retail.

CrewAI’s brokers should not solely automating routine duties, but additionally creating new roles that require superior abilities. CrewAI’s emphasis on group collaboration, by way of its modular design and ease rules, goals to transcend conventional automation, reaching a better stage of resolution simplification, creativity enhancement, and addressing advanced challenges.

CrewAI key ideas

CrewAI’s structure is constructed on a modular framework comprising a number of key parts that facilitate collaboration, delegation, and adaptive decision-making in multi-agent environments. Let’s discover every part intimately to know how they allow multi-agent interactions.

At a excessive stage, CrewAI creates two most important methods to create agentic automations: flows and crews.

Flows

CrewAI Flows present a structured, event-driven framework to orchestrate advanced, multi-step AI automations seamlessly. Flows empower customers to outline subtle workflows that mix common code, single LLM calls, and doubtlessly a number of crews, by way of conditional logic, loops, and real-time state administration. This flexibility permits companies to construct dynamic, clever automation pipelines that adapt to altering situations and evolving enterprise wants. The next determine illustrates the distinction between Crews and Flows:

When built-in with Amazon Bedrock, CrewAI Flows unlock even larger potential. Amazon Bedrock supplies a strong basis by enabling entry to highly effective basis fashions (FMs).

For instance, in a buyer assist state of affairs, a CrewAI Move orchestrated by way of Amazon Bedrock might mechanically route buyer queries to specialised AI agent crews. These crews collaboratively diagnose buyer points, work together with backend programs for information retrieval, generate personalised responses, and dynamically escalate advanced issues to human brokers solely when needed.

Equally, in monetary providers, a CrewAI Move might monitor trade situations, triggering agent-based evaluation to proactively handle funding portfolios primarily based on trade volatility and investor preferences.

Collectively, CrewAI Flows and Amazon Bedrock create a strong synergy, enabling enterprises to implement adaptive, clever automation that addresses real-world complexities effectively and at scale.

Crews

Crews in CrewAI are composed of a number of key parts, which we focus on on this part.

Brokers

Brokers in CrewAI function autonomous entities designed to carry out particular roles inside a multi-agent system. These brokers are outfitted with varied capabilities, together with reasoning, reminiscence, and the flexibility to work together dynamically with their atmosphere. Every agent is outlined by 4 most important components:

• Function – Determines the agent’s operate and duties throughout the system
• Backstory – Offers contextual data that guides the agent’s decision-making processes
• Objectives – Specifies the aims the agent goals to perform
• Instruments – Extends the capabilities of brokers to entry extra data and take actions

Brokers in CrewAI are designed to work collaboratively, making autonomous choices, delegating duties, and utilizing instruments to execute advanced workflows effectively. They’ll talk with one another, use exterior sources, and refine their methods primarily based on noticed outcomes.

Duties

Duties in CrewAI are the elemental constructing blocks that outline particular actions an agent must carry out to realize its aims. Duties will be structured as standalone assignments or interdependent workflows that require a number of brokers to collaborate. Every job contains key parameters, corresponding to:

• Description – Clearly defines what the duty entails
• Agent project – Specifies which agent is chargeable for executing the duty

Instruments

Instruments in CrewAI present brokers with prolonged capabilities, enabling them to carry out actions past their intrinsic reasoning skills. These instruments permit brokers to work together with APIs, entry databases, execute scripts, analyze information, and even talk with different exterior programs. CrewAI helps a modular software integration system the place instruments will be outlined and assigned to particular brokers, offering environment friendly and context-aware decision-making.

Course of

The method layer in CrewAI governs how brokers work together, coordinate, and delegate duties. It makes certain that multi-agent workflows function seamlessly by managing job execution, communication, and synchronization amongst brokers.

Extra particulars on CrewAI ideas will be discovered within the CrewAI documentation.

CrewAI enterprise suite

For companies in search of tailor-made AI agent options, CrewAI supplies an enterprise providing that features devoted assist, superior customization, and integration with enterprise-grade programs like Amazon Bedrock. This permits organizations to deploy AI brokers at scale whereas sustaining safety and compliance necessities.

Enterprise clients get entry to complete monitoring instruments that present deep visibility into agent operations. This contains detailed logging of agent interactions, efficiency metrics, and system well being indicators. The monitoring dashboard permits groups to trace agent conduct, establish bottlenecks, and optimize multi-agent workflows in actual time.

Actual-world enterprise influence

CrewAI clients are already seeing vital returns by adopting agentic workflows in manufacturing. On this part, we offer just a few actual buyer examples.

Legacy code modernization

A big enterprise buyer wanted to modernize their legacy ABAP and APEX code base, a sometimes time-consuming course of requiring intensive handbook effort for code updates and testing.

A number of CrewAI brokers work in parallel to:

• Analyze current code base parts
• Generate modernized code in actual time
• Execute assessments in manufacturing atmosphere
• Present fast suggestions for iterations

The buyer achieved roughly 70% enchancment in code technology pace whereas sustaining high quality by way of automated testing and suggestions loops. The answer was containerized utilizing Docker for constant deployment and scalability. The next diagram illustrates the answer structure.

Again workplace automation at world CPG firm

A number one CPG firm automated their back-office operations by connecting their current functions and information shops to CrewAI brokers that:

• Analysis trade situations
• Analyze pricing information
• Summarize findings
• Execute choices

The implementation resulted in a 75% discount in processing time by automating the whole workflow from information evaluation to motion execution. The next diagram illustrates the answer structure.

Get began with CrewAI and Amazon Bedrock

Amazon Bedrock integration with CrewAI permits the creation of production-grade AI brokers powered by state-of-the-art language fashions.

The next is a code snippet on how one can arrange this integration:

from crewai import Agent, Crew, Course of, Process, LLM
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
import os

# Configure Bedrock LLM
llm = LLM(
    mannequin="bedrock/anthropic. anthropic.claude-3-5-sonnet-20241022-v2:0",
    aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
    aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
    aws_region_name=os.getenv('AWS_REGION_NAME')
)

# Create an agent with Bedrock because the LLM supplier
security_analyst = Agent(
    config=agents_config['security_analyst'],
    instruments=[SerperDevTool(), ScrapeWebsiteTool()],
    llm=llm
)

Try the CrewAI LLM documentation for detailed directions on how one can configure LLMs together with your AI brokers.

Amazon Bedrock supplies a number of key benefits for CrewAI functions:

• Entry to state-of-the-art language fashions corresponding to Anthropic’s Claude and Amazon Nova – These fashions present the cognitive capabilities that energy agent decision-making. The fashions allow brokers to know advanced directions, generate human-like responses, and make nuanced choices primarily based on context.
• Enterprise-grade safety and compliance options – That is essential for organizations that want to take care of strict management over their information and implement compliance with varied rules.
• Scalability and reliability backed by AWS infrastructure – This implies your agent programs can deal with growing workloads whereas sustaining constant efficiency.

Amazon Bedrock Brokers and Amazon Bedrock Data Bases as native CrewAI Instruments

Amazon Bedrock Brokers provides you the flexibility to construct and configure autonomous brokers in a totally managed and serverless method on Amazon Bedrock. You don’t should provision capability, handle infrastructure, or write customized code. Amazon Bedrock manages immediate engineering, reminiscence, monitoring, encryption, person permissions, and API invocation. BedrockInvokeAgentTool permits CrewAI brokers to invoke Amazon Bedrock brokers and use their capabilities inside your workflows.

With Amazon Bedrock Data Bases, you may securely join FMs and brokers to your organization information to ship extra related, correct, and customised responses. BedrockKBRetrieverTool permits CrewAI brokers to retrieve data from Amazon Bedrock Data Bases utilizing pure language queries.

The next code exhibits an instance for Amazon Bedrock Brokers integration:

from crewai import Agent, Process, Crew

from crewai_tools.aws.bedrock.brokers.invoke_agent_tool import BedrockInvokeAgentTool

# Initialize the Bedrock Brokers Instrument

agent_tool = BedrockInvokeAgentTool(
    agent_id="your-agent-id",
    agent_alias_id="your-agent-alias-id"
)

# Create an CrewAI agent that makes use of the Bedrock Brokers Instrument

aws_expert = Agent(
    position="AWS Service Skilled",
    aim="Assist customers perceive AWS providers and quotas",
    backstory='I'm an knowledgeable in AWS providers and may present detailed details about them.',
    instruments=[agent_tool],
    verbose=True
)

The next code exhibits an instance for Amazon Bedrock Data Bases integration:

# Create and configure the BedrockKB software 
kb_tool = BedrockKBRetrieverTool(
    knowledge_base_id="your-kb-id",
    number_of_results=5
)

# Create an CrewAI agent that makes use of the Bedrock Brokers Instrument
researcher = Agent(
    position="Data Base Researcher",
    aim="Discover details about firm insurance policies",
    backstory='I'm a researcher specialised in retrieving and analyzing firm documentation.',
    instruments=[kb_tool],
    verbose=True
)

Operational excellence by way of monitoring, tracing, and observability with CrewAI on AWS

As with all software program software, reaching operational excellence is essential when deploying agentic functions in manufacturing environments. These functions are advanced programs comprising each deterministic and probabilistic parts that work together both sequentially or in parallel. Due to this fact, complete monitoring, traceability, and observability are important elements for reaching operational excellence. This contains three key dimensions:

• Software-level observability – Offers clean operation of the whole system, together with the agent orchestration framework CrewAI and doubtlessly extra software parts (corresponding to a frontend)
• Mannequin-level observability – Offers dependable mannequin efficiency (together with metrics like accuracy, latency, throughput, and extra)
• Agent-level observability – Maintains environment friendly operations inside single-agent or multi-agent programs

When operating agent-based functions with CrewAI and Amazon Bedrock on AWS, you achieve entry to a complete set of built-in capabilities throughout these dimensions:

• Software-level logs – Amazon CloudWatch mechanically collects application-level logs and metrics out of your software code operating in your chosen AWS compute platform, corresponding to AWS Lambda, Amazon Elastic Container Service (Amazon ECS), or Amazon Elastic Compute Cloud (Amazon EC2). The CrewAI framework supplies application-level logging, configured at a minimal stage by default. For extra detailed insights, verbose logging will be enabled on the agent or crew stage by setting verbose=True throughout initialization.
• Mannequin-level invocation logs – Moreover, CloudWatch mechanically collects model-level invocation logs and metrics from Amazon Bedrock. This contains important efficiency metrics.
• Agent-level observability – CrewAI seamlessly integrates with in style third-party monitoring and observability frameworks corresponding to AgentOps, Arize, MLFlow, LangFuse, and others. These frameworks allow complete tracing, debugging, monitoring, and optimization of the agent system’s efficiency.

Resolution overview

Every AWS service has its personal configuration nuances, and lacking only one element can result in critical vulnerabilities. Conventional safety assessments usually demand a number of specialists, coordinated schedules, and numerous handbook checks. With CrewAI Brokers, you may streamline the whole course of, mechanically mapping your sources, analyzing configurations, and producing clear, prioritized remediation steps.

The next diagram illustrates the answer structure.

Our use case demo implements a specialised group of three brokers, every with distinct duties that mirror roles you would possibly discover in knowledgeable safety consulting agency:

• Infrastructure mapper – Acts as our system architect, methodically documenting AWS sources and their configurations. Like an skilled cloud architect, it creates an in depth stock that serves as the inspiration for our safety evaluation.
• Safety analyst – Serves as our cybersecurity knowledgeable, analyzing the infrastructure map for potential vulnerabilities and researching present greatest practices. It brings deep information of safety threats and mitigation methods.
• Report author – Features as our technical documentation specialist, synthesizing advanced findings into clear, actionable suggestions. It makes certain that technical insights are communicated successfully to each technical and non-technical stakeholders.

Implement the answer

On this part, we stroll by way of the implementation of a safety evaluation multi-agent system. The code for this instance is positioned on GitHub. Word that not all code artifacts of the answer are explicitly lined on this put up.

Step 1: Configure the Amazon Bedrock LLM

We’ve saved our surroundings variables in an .env file in our root listing earlier than we go them to the LLM class:

from crewai import Agent, Crew, Course of, Process, LLM 
from crewai.venture import CrewBase, agent, crew, job 

from aws_infrastructure_security_audit_and_reporting.instruments.aws_infrastructure_scanner_tool import AWSInfrastructureScannerTool 
from crewai_tools import SerperDevTool, ScrapeWebsiteTool 
import os 

@CrewBase 
class AwsInfrastructureSecurityAuditAndReportingCrew():  
    """AwsInfrastructureSecurityAuditAndReporting crew""" 
    def __init__(self) -> None: 
        self.llm = LLM( mannequin=os.getenv('MODEL'),
        aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
        aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
        aws_region_name=os.getenv('AWS_REGION_NAME') 
    )

Step 2: Outline brokers

These brokers are already outlined within the brokers.yaml file, and we’re importing them into every agent operate within the crew.py file:

...
# Configure AI Brokers

@agent 	 
def infrastructure_mapper(self) -> Agent:
    return Agent( 	 
        config=self.agents_config['infrastructure_mapper'],
        instruments=[AWSInfrastructureScannerTool()],
        llm=self.llm 	 
    ) 	 	 

@agent 	 
def security_analyst(self) -> Agent:
    return Agent( 	 
        config=self.agents_config['security_analyst'], 	 
        instruments=[SerperDevTool(), ScrapeWebsiteTool()],
        llm=self.llm 	 
    ) 	 	

@agent 	 
def report_writer(self) -> Agent: 	 
    return Agent( 	 
        config=self.agents_config['report_writer'], 	 
        llm=self.llm 	 
    )

Step 3: Outline duties for the brokers

Much like our brokers within the previous code, we import duties.yaml into our crew.py file:

...
# Configure Duties for the brokers

@job 
def map_aws_infrastructure_task(self) -> Process: 
    return Process( 
        config=self.tasks_config['map_aws_infrastructure_task']
    ) 

@job 
def exploratory_security_analysis_task(self) -> Process: 
    return Process( 
        config=self.tasks_config['exploratory_security_analysis_task']
    ) 

@job 
def generate_report_task(self) -> Process: 
    return Process( 
        config=self.tasks_config['generate_report_task'] 
    )

Step 4: Create the AWS infrastructure scanner software

This software permits our brokers to work together with AWS providers and retrieve data they should carry out their evaluation:

class AWSInfrastructureScannerTool(BaseTool):
    identify: str = "AWS Infrastructure Scanner"
    description: str = (
        "A software for scanning and mapping AWS infrastructure parts and their     configurations. "
        "Can retrieve detailed details about EC2 cases, S3 buckets, IAM configurations, "
        "RDS cases, VPC settings, and safety teams. Use this software to collect data "
        "about particular AWS providers or get an entire infrastructure overview."
    )
    args_schema: Kind[BaseModel] = AWSInfrastructureScannerInput

    def _run(self, service: str, area: str) -> str:
        strive:
            if service.decrease() == 'all':
                return json.dumps(self._scan_all_services(area), indent=2, cls=DateTimeEncoder)
            return json.dumps(self._scan_service(service.decrease(), area), indent=2, cls=DateTimeEncoder)
        besides Exception as e:
            return f"Error scanning AWS infrastructure: {str(e)}"

    def _scan_all_services(self, area: str) -> Dict:
        return {
            'ec2': self._scan_service('ec2', area),
            's3': self._scan_service('s3', area),
            'iam': self._scan_service('iam', area),
            'rds': self._scan_service('rds', area),
            'vpc': self._scan_service('vpc', area)
        }                                       
   
   # Extra providers will be added right here

Step 5: Assemble the safety audit crew

Carry the parts collectively in a coordinated crew to execute on the duties:

@crew
def crew(self) -> Crew:
    """Creates the AwsInfrastructureSecurityAuditAndReporting crew"""
    return Crew(
        brokers=self.brokers, # Routinely created by the @agent decorator
        duties=self.duties, # Routinely created by the @job decorator
        course of=Course of.sequential,
        verbose=True,
    )

Step 6: Run the crew

In our most important.py file, we import our crew and go in inputs to the crew to run:

def run():
    """
    Run the crew.
    """
    inputs = {}
    AwsInfrastructureSecurityAuditAndReportingCrew().crew().kickoff(inputs=inputs)

The ultimate report will look one thing like the next code:

```markdown
### Government Abstract

In response to an pressing want for strong safety inside AWS infrastructure, this evaluation recognized a number of vital areas requiring fast consideration throughout EC2 Situations, S3 Buckets, and IAM Configurations. Our evaluation revealed two high-priority points that pose vital dangers to the group's safety posture.

### Threat Evaluation Matrix

| Safety Element | Threat Description | Affect | Probability | Precedence |
|--------------------|------------------|---------|------------|----------|
| S3 Buckets | Unintended public entry | Excessive | Excessive | Vital |
| EC2 Situations | SSRF by way of Metadata | Excessive | Medium | Excessive |
| IAM Configurations | Permission sprawl | Medium | Excessive | Medium |

### Prioritized Remediation Roadmap

1. **Rapid (0-30 days):**
   - Implement IMDSv2 on all EC2 cases
   - Conduct S3 bucket permission audit and rectify public entry points
   - Modify safety group guidelines to eradicate broad entry

2. **Brief Time period (30-60 days):**
   - Conduct IAM coverage audit to eradicate unused permissions
   - Prohibit RDS entry to identified IP ranges
```

This implementation exhibits how CrewAI brokers can work collectively to carry out advanced safety assessments that may sometimes require a number of safety professionals. The system is each scalable and customizable, permitting for adaptation to particular safety necessities and compliance requirements.

Conclusion

On this put up, we demonstrated how one can use CrewAI and Amazon Bedrock to construct a classy, automated safety evaluation system for AWS infrastructure. We explored how a number of AI brokers can work collectively seamlessly to carry out advanced safety audits, from infrastructure mapping to vulnerability evaluation and report technology. By way of our instance implementation, we showcased how CrewAI’s framework permits the creation of specialised brokers, every bringing distinctive capabilities to the safety evaluation course of. By integrating with highly effective language fashions utilizing Amazon Bedrock, we created a system that may autonomously establish safety dangers, analysis options, and generate actionable suggestions.

The sensible instance we shared illustrates simply one among many attainable functions of CrewAI with Amazon Bedrock. The mix of CrewAI’s agent orchestration capabilities and superior language fashions in Amazon Bedrock opens up quite a few potentialities for constructing clever, autonomous programs that may sort out advanced enterprise challenges.

We encourage you to discover our code on GitHub and begin constructing your personal multi-agent programs utilizing CrewAI and Amazon Bedrock. Whether or not you’re targeted on safety assessments, course of automation, or different use instances, this highly effective mixture supplies the instruments it’s essential create subtle AI options that may scale together with your wants.

Concerning the Authors

Tony Kipkemboi is a Senior Developer Advocate and Partnerships Lead at CrewAI, the place he empowers builders to construct AI brokers that drive enterprise effectivity. A US Military veteran, Tony brings a various background in healthcare, information engineering, and AI. With a ardour for innovation, he has spoken at occasions like PyCon US and contributes to the tech group by way of open supply initiatives, tutorials, and thought management in AI agent improvement. Tony holds a Bachelor’s of Science in Well being Sciences and is pursuing a Grasp’s in Laptop Data Expertise on the College of Pennsylvania.

João (Joe) Moura is the Founder and CEO of CrewAI, the main agent orchestration platform powering multi-agent automations at scale. With deep experience in generative AI and enterprise options, João companions with world leaders like AWS, NVIDIA, IBM, and Meta AI to drive modern AI methods. Below his management, CrewAI has quickly develop into important infrastructure for top-tier corporations and builders worldwide and utilized by many of the F500 within the US.

Karan Singh is a Generative AI Specialist at AWS, the place he works with top-tier third-party basis mannequin and agentic frameworks suppliers to develop and execute joint go-to-market methods, enabling clients to successfully deploy and scale options to resolve enterprise generative AI challenges. Karan holds a Bachelor’s of Science in Electrical Engineering from Manipal College, a Grasp’s in Science in Electrical Engineering from Northwestern College, and an MBA from the Haas College of Enterprise at College of California, Berkeley.

Aris Tsakpinis is a Specialist Options Architect for Generative AI specializing in open supply fashions on Amazon Bedrock and the broader generative AI open supply ecosystem. Alongside his skilled position, he’s pursuing a PhD in Machine Studying Engineering on the College of Regensburg, the place his analysis focuses on utilized pure language processing in scientific domains.