Construct agentic techniques with CrewAI and Amazon Bedrock

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

The enterprise AI panorama is present process a seismic shift as agentic techniques transition from experimental instruments to mission-critical enterprise property. In 2025, AI brokers are anticipated to turn out to be 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 area 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 submit, we discover how CrewAI’s open supply agentic framework, mixed with Amazon Bedrock, permits the creation of subtle multi-agent techniques that may rework how companies function. By way of sensible examples and implementation particulars, we reveal learn how to construct, deploy, and orchestrate AI brokers that may sort out complicated duties with minimal human oversight. Though “brokers” is the buzzword of 2025, it’s essential to grasp 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 massive language fashions (LLMs) and different AI capabilities to carry out complicated duties with minimal human oversight. Not like conventional software program, which follows pre-defined guidelines, AI brokers can function independently, be taught from their surroundings, adapt to altering circumstances, and make contextual selections. They’re designed with modular parts, corresponding to reasoning engines, reminiscence, cognitive expertise, and instruments, that allow them to execute subtle workflows. Conventional SaaS options are designed for horizontal scalability and normal applicability, which makes them appropriate for managing repetitive duties throughout numerous sectors, however they usually lack domain-specific intelligence and the pliability to deal with distinctive challenges in dynamic environments. Agentic techniques, however, are designed to bridge this hole by combining the pliability of context-aware techniques with area data. 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 complicated design challenges. For instance, for the CrewAI git repository, pull requests are evaluated by a set of CrewAI brokers who evaluate code primarily based on code documentation, consistency of implementation, and safety issues. One other use case could be seen in provide chain administration, the place conventional stock techniques 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 assets. 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 techniques, or a mixture of each, enabling brokers to work collectively seamlessly, tackling complicated duties by way of collaborative intelligence. The next determine illustrates the aptitude of CrewAI’s enterprise providing:

CrewAI’s design facilities across the potential 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 function, purpose, and backstory, and may entry particular instruments to perform their targets. This framework permits for autonomous inter-agent delegation, the place brokers can delegate duties and inquire amongst themselves, enhancing problem-solving effectivity. This progress is fueled by the growing demand for clever automation and personalised buyer experiences throughout sectors like healthcare, finance, and retail.

CrewAI’s brokers usually are not solely automating routine duties, but additionally creating new roles that require superior expertise. CrewAI’s emphasis on workforce collaboration, by way of its modular design and ease ideas, goals to transcend conventional automation, reaching the next stage of determination simplification, creativity enhancement, and addressing complicated 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 grasp how they allow multi-agent interactions.

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

Flows

CrewAI Flows present a structured, event-driven framework to orchestrate complicated, multi-step AI automations seamlessly. Flows empower customers to outline subtle workflows that mix common code, single LLM calls, and probably 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 circumstances 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 sturdy basis by enabling entry to highly effective basis fashions (FMs).

For instance, in a buyer help situation, a CrewAI Circulate orchestrated by way of Amazon Bedrock might robotically route buyer queries to specialised AI agent crews. These crews collaboratively diagnose buyer points, work together with backend techniques for information retrieval, generate personalised responses, and dynamically escalate complicated issues to human brokers solely when mandatory.

Equally, in monetary companies, a CrewAI Circulate might monitor trade circumstances, 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 robust 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 talk about on this part.

Brokers

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

• Function – Determines the agent’s operate and duties inside the system
• Backstory – Supplies contextual data that guides the agent’s decision-making processes
• Objectives – Specifies the targets 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 selections, delegating duties, and utilizing instruments to execute complicated workflows effectively. They’ll talk with one another, use exterior assets, 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 attain its targets. Duties could be structured as standalone assignments or interdependent workflows that require a number of brokers to collaborate. Every process consists of key parameters, corresponding to:

• Description – Clearly defines what the duty entails
• Agent project – Specifies which agent is accountable 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 techniques. CrewAI helps a modular software integration system the place instruments could 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 positive that multi-agent workflows function seamlessly by managing process execution, communication, and synchronization amongst brokers.

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

CrewAI enterprise suite

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

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

Actual-world enterprise impression

CrewAI prospects are already seeing important returns by adopting agentic workflows in manufacturing. On this part, we offer a couple of 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 guide effort for code updates and testing.

A number of CrewAI brokers work in parallel to:

• Analyze present code base parts
• Generate modernized code in actual time
• Execute checks in manufacturing surroundings
• Present quick suggestions for iterations

The buyer achieved roughly 70% enchancment in code era velocity 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 present purposes and information shops to CrewAI brokers that:

• Analysis trade circumstances
• Analyze pricing information
• Summarize findings
• Execute selections

The implementation resulted in a 75% discount in processing time by automating the complete 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 learn how to 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 learn how to configure LLMs along with your AI brokers.

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

• 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 grasp complicated directions, generate human-like responses, and make nuanced selections 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 techniques can deal with growing workloads whereas sustaining constant efficiency.

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

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

With Amazon Bedrock Information Bases, you possibly can 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 Information 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(
    function="AWS Service Skilled",
    purpose="Assist customers perceive AWS companies and quotas",
    backstory='I'm an professional in AWS companies and may present detailed details about them.',
    instruments=[agent_tool],
    verbose=True
)

The next code exhibits an instance for Amazon Bedrock Information 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(
    function="Information Base Researcher",
    purpose="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 every software program utility, reaching operational excellence is essential when deploying agentic purposes in manufacturing environments. These purposes are complicated techniques comprising each deterministic and probabilistic parts that work together both sequentially or in parallel. Subsequently, complete monitoring, traceability, and observability are important components for reaching operational excellence. This consists of three key dimensions:

• Software-level observability – Supplies easy operation of the complete system, together with the agent orchestration framework CrewAI and probably extra utility parts (corresponding to a frontend)
• Mannequin-level observability – Supplies 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 techniques

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

• Software-level logs – Amazon CloudWatch robotically collects application-level logs and metrics out of your utility code working 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 could be enabled on the agent or crew stage by setting verbose=True throughout initialization.
• Mannequin-level invocation logs – Moreover, CloudWatch robotically collects model-level invocation logs and metrics from Amazon Bedrock. This consists of 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.

Answer overview

Every AWS service has its personal configuration nuances, and lacking only one element can result in severe vulnerabilities. Conventional safety assessments usually demand a number of consultants, coordinated schedules, and numerous guide checks. With CrewAI Brokers, you possibly can streamline the complete course of, robotically mapping your assets, analyzing configurations, and producing clear, prioritized remediation steps.

The next diagram illustrates the answer structure.

Our use case demo implements a specialised workforce 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 assets and their configurations. Like an skilled cloud architect, it creates an in depth stock that serves as the muse for our safety evaluation.
• Safety analyst – Serves as our cybersecurity professional, analyzing the infrastructure map for potential vulnerabilities and researching present finest practices. It brings deep data of safety threats and mitigation methods.
• Report author – Capabilities as our technical documentation specialist, synthesizing complicated findings into clear, actionable suggestions. It makes positive 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. Observe that not all code artifacts of the answer are explicitly lined on this submit.

Step 1: Configure the Amazon Bedrock LLM

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

from crewai import Agent, Crew, Course of, Process, LLM 
from crewai.challenge import CrewBase, agent, crew, process 

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

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

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

@process 
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 companies 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 companies 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 companies could 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, # Robotically created by the @agent decorator
        duties=self.duties, # Robotically created by the @process decorator
        course of=Course of.sequential,
        verbose=True,
    )

Step 6: Run the crew

In our predominant.py file, we import our crew and move 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
### Govt Abstract

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

### Danger Evaluation Matrix

| Safety Part | Danger Description | Affect | Chance | 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. **Instant (0-30 days):**
   - Implement IMDSv2 on all EC2 cases
   - Conduct S3 bucket permission audit and rectify public entry points
   - Regulate safety group guidelines to remove broad entry

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

This implementation exhibits how CrewAI brokers can work collectively to carry out complicated safety assessments that might 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 submit, we demonstrated learn how to 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 complicated safety audits, from infrastructure mapping to vulnerability evaluation and report era. 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 determine safety dangers, analysis options, and generate actionable suggestions.

The sensible instance we shared illustrates simply one in every of many doable purposes 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 prospects for constructing clever, autonomous techniques that may sort out complicated enterprise challenges.

We encourage you to discover our code on GitHub and begin constructing your personal multi-agent techniques utilizing CrewAI and Amazon Bedrock. Whether or not you’re targeted on safety assessments, course of automation, or different use circumstances, this highly effective mixture supplies the instruments you want to create subtle AI options that may scale along 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 neighborhood 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. Underneath his management, CrewAI has quickly turn out to be important infrastructure for top-tier firms and builders worldwide and utilized by a lot 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 prospects to successfully deploy and scale options to unravel 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 function, 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.