Construct agentic techniques with CrewAI and Amazon Bedrock

This publish 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 change 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 global AI agent space 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 publish, we discover how CrewAI’s open source agentic framework, mixed with Amazon Bedrock, allows the creation of subtle multi-agent techniques that may rework how companies function. By sensible examples and implementation particulars, we reveal the best way 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 vital to know what an AI agent is and the place deploying an agentic system may 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 complicated duties with minimal human oversight. In contrast to conventional software program, which follows pre-defined guidelines, AI brokers can function independently, be taught from their atmosphere, adapt to altering circumstances, and make contextual selections. They’re designed with modular elements, akin to reasoning engines, reminiscence, cognitive abilities, and instruments, that allow them to execute subtle workflows. Conventional SaaS options are designed for horizontal scalability and basic applicability, which makes them appropriate for managing repetitive duties throughout various sectors, however they usually lack domain-specific intelligence and the pliability to deal with distinctive challenges in dynamic environments. Agentic techniques, alternatively, 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 evaluation code based mostly on code documentation, consistency of implementation, and safety concerns. One other use case may be seen in provide chain administration, the place conventional stock techniques may monitor inventory ranges, however lack the potential to anticipate provide chain disruptions or optimize procurement based mostly on business insights. In distinction, an agentic system can use real-time information (akin to climate or geopolitical dangers) to proactively reroute provide chains and reallocate sources. The next illustration describes the elements 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 mix of each, enabling brokers to work collectively seamlessly, tackling complicated duties by means of collaborative intelligence. The next determine illustrates the potential of CrewAI’s enterprise providing:

CrewAI’s design facilities across the means to construct AI automation by means of flows and crews of AI brokers. It excels on the relationship between brokers and duties, the place every agent has an outlined function, aim, 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 development is fueled by the rising demand for clever automation and customized buyer experiences throughout sectors like healthcare, finance, and retail.

CrewAI’s brokers aren’t solely automating routine duties, but additionally creating new roles that require superior abilities. CrewAI’s emphasis on group collaboration, by means of its modular design and ease rules, goals to transcend conventional automation, attaining the next stage of choice simplification, creativity enhancement, and addressing complicated challenges.

CrewAI key ideas

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

At a excessive stage, CrewAI creates two fundamental 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 doubtlessly a number of crews, by means 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 better 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 Circulation orchestrated by means of Amazon Bedrock may robotically route buyer queries to specialised AI agent crews. These crews collaboratively diagnose buyer points, work together with backend techniques for information retrieval, generate customized responses, and dynamically escalate complicated issues to human brokers solely when essential.

Equally, in monetary companies, a CrewAI Circulation may monitor business circumstances, triggering agent-based evaluation to proactively handle funding portfolios based mostly on business 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 elements, 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 flexibility to work together dynamically with their atmosphere. Every agent is outlined by 4 fundamental parts:

• Function – Determines the agent’s operate and obligations inside the system
• Backstory – Offers contextual info that guides the agent’s decision-making processes
• Targets – Specifies the targets the agent goals to perform
• Instruments – Extends the capabilities of brokers to entry extra info 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 will talk with one another, use exterior sources, and refine their methods based mostly 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 may be structured as standalone assignments or interdependent workflows that require a number of brokers to collaborate. Every job contains key parameters, akin to:

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

Instruments

Instruments in CrewAI present brokers with prolonged capabilities, enabling them to carry out actions past their intrinsic reasoning talents. These instruments enable brokers to work together with APIs, entry databases, execute scripts, analyze information, and even talk with different exterior techniques. CrewAI helps a modular device integration system the place instruments may 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 job execution, communication, and synchronization amongst brokers.

Extra particulars on CrewAI ideas may 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 assist, 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 contains detailed logging of agent interactions, efficiency metrics, and system well being indicators. The monitoring dashboard allows groups to trace agent conduct, establish 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 handbook effort for code updates and testing.

A number of CrewAI brokers work in parallel to:

• Analyze current code base elements
• Generate modernized code in actual time
• Execute checks in manufacturing atmosphere
• Present instant suggestions for iterations

The customer achieved approximately 70% improvement in code era pace whereas sustaining high quality by means 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 purposes and information shops to CrewAI brokers that:

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

The implementation resulted in a 75% discount in processing time by automating your entire 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 allows the creation of production-grade AI brokers powered by state-of-the-art language fashions.

The next is a code snippet on the best way 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 the best way 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 akin to Anthropic’s Claude and Amazon Nova – These fashions present the cognitive capabilities that energy agent decision-making. The fashions allow brokers to know complicated directions, generate human-like responses, and make nuanced selections based mostly 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 laws.
• Scalability and reliability backed by AWS infrastructure – This implies your agent techniques can deal with rising workloads whereas sustaining constant efficiency.

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

Amazon Bedrock Brokers affords you the flexibility to construct and configure autonomous brokers in a completely 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, consumer permissions, and API invocation. BedrockInvokeAgentTool allows CrewAI brokers to invoke Amazon Bedrock brokers and use their capabilities inside your workflows.

With Amazon Bedrock Data Bases, you possibly can securely join FMs and brokers to your organization information to ship extra related, correct, and customised responses. BedrockKBRetrieverTool allows CrewAI brokers to retrieve info 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 Device

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 Device

aws_expert = Agent(
    function="AWS Service Skilled",
    aim="Assist customers perceive AWS companies and quotas",
    backstory='I'm an skilled in AWS companies 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 device 
kb_tool = BedrockKBRetrieverTool(
    knowledge_base_id="your-kb-id",
    number_of_results=5
)

# Create an CrewAI agent that makes use of the Bedrock Brokers Device
researcher = Agent(
    function="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 means of monitoring, tracing, and observability with CrewAI on AWS

As with all software program software, attaining operational excellence is essential when deploying agentic purposes in manufacturing environments. These purposes are complicated techniques comprising each deterministic and probabilistic elements that work together both sequentially or in parallel. Subsequently, complete monitoring, traceability, and observability are important components for attaining operational excellence. This contains three key dimensions:

• Software-level observability – Offers easy operation of your entire system, together with the agent orchestration framework CrewAI and doubtlessly further software elements (akin 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 techniques

When operating agent-based purposes 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 robotically collects application-level logs and metrics out of your software code operating in your chosen AWS compute platform, akin 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 may 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 contains important efficiency metrics.
• Agent-level observability – CrewAI seamlessly integrates with common third-party monitoring and observability frameworks akin 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 possibly can streamline your entire course of, robotically 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 obligations that mirror roles you may 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 skilled, analyzing the infrastructure map for potential vulnerabilities and researching present finest practices. It brings deep data of safety threats and mitigation methods.
• Report author – Features 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 means of the implementation of a safety evaluation multi-agent system. The code for this instance is situated on GitHub. Observe that not all code artifacts of the answer are explicitly lined on this publish.

Step 1: Configure the Amazon Bedrock LLM

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

from crewai import Agent, Crew, Course of, Process, LLM 
from crewai.challenge 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

Just 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 device

This device allows our brokers to work together with AWS companies and retrieve info they should carry out their evaluation:

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

    def _run(self, service: str, area: str) -> str:
        attempt:
            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 may be added right here

Step 5: Assemble the safety audit crew

Deliver the elements 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 fundamental.py file, we import our crew and cross 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 strong safety inside AWS infrastructure, this evaluation recognized a number of vital areas requiring instant consideration throughout EC2 Cases, 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 | Probability | Precedence |
|--------------------|------------------|---------|------------|----------|
| S3 Buckets | Unintended public entry | Excessive | Excessive | Vital |
| EC2 Cases | SSRF by means of Metadata | Excessive | Medium | Excessive |
| IAM Configurations | Permission sprawl | Medium | Excessive | Medium |

### Prioritized Remediation Roadmap

1. **Speedy (0-30 days):**
   - Implement IMDSv2 on all EC2 situations
   - Conduct S3 bucket permission audit and rectify public entry points
   - Alter safety group guidelines to remove broad entry

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

This implementation exhibits how CrewAI brokers can work collectively to carry out complicated 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 publish, we demonstrated the best way 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 our instance implementation, we showcased how CrewAI’s framework allows 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 certainly one of many attainable purposes of CrewAI with Amazon Bedrock. The mixture of CrewAI’s agent orchestration capabilities and superior language fashions in Amazon Bedrock opens up quite a few potentialities 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 should create subtle AI options that may scale along with your wants.

In regards to 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 means of open supply tasks, 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 Pc Info 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 progressive AI methods. Underneath his management, CrewAI has quickly change 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 prospects 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 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.