CrewAI vs AutoGen: Multi-Agent Frameworks Compared

Introduction to Multi-Agent Frameworks

Multi-agent frameworks represent a paradigm shift in how we build AI applications. Instead of relying on a single large language model to handle complex tasks end-to-end, these frameworks orchestrate multiple specialized agents that collaborate, debate, and iteratively refine outputs. Two of the most prominent frameworks in this space are CrewAI and AutoGen, both open-source Python libraries that enable developers to compose agent teams with distinct roles, tools, and communication patterns.

CrewAI, inspired by the "crew" metaphor, focuses on role-based agent orchestration with a sequential or hierarchical task execution model. AutoGen, developed by Microsoft Research, emphasizes conversational agent patterns with sophisticated code execution capabilities and flexible group chat topologies. Understanding their differences, strengths, and ideal use cases is essential for any developer building compound AI systems.

Why Multi-Agent Systems Matter

Single-agent LLM applications face fundamental limitations. A lone agent must juggle reasoning, tool use, validation, and error recovery within a single context window. This often leads to:

• Context overload — stuffing too many instructions and examples into one prompt
• Lack of specialization — one model cannot excel simultaneously at creative writing, code review, and data analysis
• No self-critique loop — without a separate reviewer agent, mistakes propagate unchecked
• Sequential tool-calling bottlenecks — a single agent cannot parallelize independent subtasks effectively

Multi-agent frameworks solve these problems by distributing responsibilities. A researcher agent gathers information, a writer agent composes content, a reviewer agent critiques it, and a coordinator agent manages the workflow. This mirrors how human teams operate and produces dramatically more robust outputs, especially for complex, multi-step tasks like research report generation, codebase analysis, or customer support triage.

CrewAI: Role-Based Agent Orchestration

Core Concepts

CrewAI organizes agents around three core abstractions:

• Agents — autonomous units with a role, goal, backstory, and optional tools
• Tasks — discrete units of work with descriptions and expected outputs
• Crews — containers that orchestrate agents and tasks in a defined process

The framework supports two process types: sequential (tasks execute one after another) and hierarchical (a manager agent delegates tasks to specialized agents). CrewAI integrates natively with LangChain tools and supports any LLM provider compatible with LiteLLM.

Installing and Setting Up CrewAI

# Install CrewAI and dependencies
pip install crewai
pip install 'crewai[tools]'  # optional, for pre-built tools

# Set your API key
export OPENAI_API_KEY="sk-your-key-here"

Building Your First Crew

Let's build a simple research and writing crew with two agents: a researcher that gathers web data and a writer that synthesizes findings into a concise report.

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# Set up API keys
os.environ["OPENAI_API_KEY"] = "your-openai-key"
os.environ["SERPER_API_KEY"] = "your-serper-key"  # for web search tool

# Create a search tool
search_tool = SerperDevTool()

# Define the Researcher Agent
researcher = Agent(
    role="Senior Technology Researcher",
    goal="Discover and compile the latest developments in the given topic area",
    backstory=(
        "You are a seasoned researcher with 15 years of experience in technology analysis. "
        "You excel at finding authoritative sources, cross-referencing claims, and "
        "synthesizing scattered information into coherent summaries."
    ),
    tools=[search_tool],
    verbose=True,
    allow_delegation=False
)

# Define the Writer Agent
writer = Agent(
    role="Technical Content Writer",
    goal="Transform research findings into engaging, well-structured reports",
    backstory=(
        "You are an award-winning technical writer known for making complex topics "
        "accessible. Your reports always include clear sections, actionable takeaways, "
        "and a compelling narrative flow."
    ),
    verbose=True,
    allow_delegation=False
)

# Define Tasks
research_task = Task(
    description=(
        "Research the current state of quantum computing in 2024. "
        "Focus on: 1) Major hardware breakthroughs, 2) Key software developments, "
        "3) Commercial adoption trends. Use only sources from the last 6 months."
    ),
    expected_output=(
        "A comprehensive research brief with bullet points for each focus area, "
        "including source citations and dates."
    ),
    agent=researcher
)

writing_task = Task(
    description=(
        "Using the research brief provided, write a 3-paragraph executive summary "
        "on quantum computing trends. Make it engaging and accessible to a "
        "non-technical executive audience."
    ),
    expected_output="A polished, 3-paragraph executive summary in markdown format.",
    agent=writer
)

# Create the Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=2
)

# Execute
result = crew.kickoff()
print(result)

Hierarchical Crew with a Manager

For more complex workflows, a hierarchical process lets a manager agent dynamically assign tasks. This is powerful when the task sequence isn't known in advance.

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# Manager LLM (often needs stronger reasoning)
manager_llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2)

# Specialized agents
coder = Agent(
    role="Python Developer",
    goal="Write clean, tested Python code based on specifications",
    backstory="Senior engineer with deep Python expertise and TDD discipline.",
    tools=[],  # could add code execution tools here
    verbose=True
)

tester = Agent(
    role="QA Engineer",
    goal="Review code for bugs, edge cases, and performance issues",
    backstory="Detail-oriented QA lead with 10 years of experience.",
    verbose=True
)

# The crew with a manager
dev_crew = Crew(
    agents=[coder, tester],
    tasks=[],  # tasks will be dynamically assigned by the manager
    process=Process.hierarchical,
    manager_llm=manager_llm,
    verbose=2
)

# Kickoff with a high-level objective
result = dev_crew.kickoff({
    "objective": "Build a REST API endpoint that accepts JSON with user data, "
                 "validates it, and stores it in a SQLite database."
})
print(result)

Custom Tools in CrewAI

You can create custom tools by subclassing BaseTool from the crewai_tools package or by using the simpler tool decorator pattern:

from crewai_tools import BaseTool
from pydantic import BaseModel, Field
import requests

class WikipediaSearchInput(BaseModel):
    query: str = Field(description="Search query for Wikipedia")

class WikipediaSearchTool(BaseTool):
    name: str = "Wikipedia Search"
    description: str = "Search Wikipedia for information on any topic"
    args_schema: type = WikipediaSearchInput
    
    def _run(self, query: str) -> str:
        """Execute the Wikipedia search"""
        url = f"https://en.wikipedia.org/w/api.php"
        params = {
            "action": "query",
            "list": "search",
            "srsearch": query,
            "format": "json"
        }
        response = requests.get(url, params=params)
        data = response.json()
        results = data.get("query", {}).get("search", [])
        return "\n".join([r["title"] + ": " + r["snippet"] for r in results[:5]])

# Use in an agent
researcher_agent = Agent(
    role="Researcher",
    goal="Find accurate information",
    tools=[WikipediaSearchTool()],
    backstory="Expert researcher",
    verbose=True
)

AutoGen: Conversational Multi-Agent Programming

Core Concepts

AutoGen, created by Microsoft Research, takes a fundamentally different approach. It models agents as conversable entities that exchange messages in structured conversations. Its key abstractions include:

• ConversableAgents — agents that can send and receive messages, generate replies, and maintain conversation context
• GroupChat — a multi-agent conversation with a shared context and a moderator (speaker selection mechanism)
• AssistantAgent & UserProxyAgent — two primary agent types: the assistant generates responses using an LLM; the user proxy acts as a human-in-the-loop or executes code on behalf of other agents
• CodeExecutor — agents can generate, review, and execute Python code in sandboxed environments, with results fed back into the conversation

Installing AutoGen

# Install AutoGen
pip install pyautogen

# Recommended: install docker for safe code execution
# AutoGen can use Docker to sandbox code execution
pip install docker

Building a Simple Two-Agent Conversation

The classic AutoGen pattern pairs an AssistantAgent (LLM-powered) with a UserProxyAgent (simulates a user and can execute code). This creates a feedback loop where the assistant proposes solutions and the user proxy validates them.

import autogen

# Configure the LLM
config_list = [
    {
        "model": "gpt-4-turbo",
        "api_key": "your-openai-api-key",
    }
]

# Create the Assistant Agent
assistant = autogen.AssistantAgent(
    name="assistant",
    system_message=(
        "You are a helpful Python coding assistant. When asked to solve a problem, "
        "write complete, runnable Python code. Explain your reasoning before the code."
    ),
    llm_config={"config_list": config_list, "temperature": 0.2},
)

# Create the User Proxy Agent (can execute code)
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",  # auto-execute without human approval
    max_consecutive_auto_reply=3,
    code_execution_config={
        "work_dir": "coding_workspace",
        "use_docker": False,  # set True if Docker is available
    },
)

# Initiate the conversation
user_proxy.initiate_chat(
    assistant,
    message=(
        "I have a CSV file 'sales.csv' with columns: date, product, quantity, price. "
        "Write Python code to: 1) Load the data, 2) Calculate total revenue per product, "
        "3) Plot a bar chart of revenue by product, 4) Save the chart as 'revenue_chart.png'."
    ),
)

Group Chat with Multiple Specialized Agents

AutoGen's GroupChat orchestrates multiple agents in a shared conversation. A GroupChatManager selects which agent speaks next based on conversation history and agent roles.

import autogen

config_list = [{"model": "gpt-4-turbo", "api_key": "your-key"}]

# Define specialized agents
planner = autogen.AssistantAgent(
    name="Planner",
    system_message=(
        "You are a strategic planner. Given a complex task, break it down into "
        "clear, sequential subtasks. Assign each subtask to the most appropriate agent."
    ),
    llm_config={"config_list": config_list, "temperature": 0.1},
)

researcher = autogen.AssistantAgent(
    name="Researcher",
    system_message=(
        "You gather information using available tools and data. Provide factual, "
        "well-sourced responses. If you don't know something, say so clearly."
    ),
    llm_config={"config_list": config_list},
)

writer = autogen.AssistantAgent(
    name="Writer",
    system_message=(
        "You are a skilled content writer. Take structured information and craft "
        "it into engaging, clear prose. Use active voice and avoid jargon."
    ),
    llm_config={"config_list": config_list},
)

critic = autogen.AssistantAgent(
    name="Critic",
    system_message=(
        "You review content critically. Check for factual errors, logical gaps, "
        "poor structure, and stylistic issues. Provide specific, actionable feedback."
    ),
    llm_config={"config_list": config_list},
)

# Human proxy for final approval
user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="TERMINATE",  # ask human only when task is complete
    code_execution_config=False,
)

# Create GroupChat
groupchat = autogen.GroupChat(
    agents=[user_proxy, planner, researcher, writer, critic],
    messages=[],
    max_round=15,
    speaker_selection_method="round_robin",  # or "auto" for LLM-based selection
)

manager = autogen.GroupChatManager(
    groupchat=groupchat,
    llm_config={"config_list": config_list},
)

# Launch the group conversation
user_proxy.initiate_chat(
    manager,
    message=(
        "Create a comprehensive 2-page report on the impact of generative AI "
        "on the software development industry in 2024. Include statistics, "
        "trends, and expert opinions."
    ),
)

AutoGen's Code Execution Superpower

One of AutoGen's most distinctive features is its ability to generate, execute, and iterate on code within conversations. The UserProxyAgent can run Python code in a sandbox (local or Docker) and feed results back to the assistant for refinement.

import autogen

config_list = [{"model": "gpt-4-turbo", "api_key": "your-key"}]

# Assistant that generates code
coder = autogen.AssistantAgent(
    name="PythonCoder",
    system_message=(
        "You are an expert Python developer. When asked to perform data analysis, "
        "write complete scripts that handle edge cases and include error handling. "
        "Always print results clearly."
    ),
    llm_config={"config_list": config_list, "temperature": 0},
)

# User proxy that executes code and returns results
executor = autogen.UserProxyAgent(
    name="CodeExecutor",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=5,
    code_execution_config={
        "work_dir": "analysis_output",
        "use_docker": True,  # safer execution in Docker container
        "timeout": 60,        # 60-second timeout
    },
    system_message=(
        "You execute Python code provided by the coder and return the output. "
        "If errors occur, report them clearly so the coder can fix them."
    ),
)

executor.initiate_chat(
    coder,
    message=(
        "Analyze the following dataset using Python. Generate a script that:\n"
        "1. Downloads the Iris dataset from sklearn\n"
        "2. Performs exploratory data analysis (describe, correlations, pairplot)\n"
        "3. Trains a simple RandomForest classifier\n"
        "4. Reports accuracy, confusion matrix, and feature importance\n"
        "Save all visualizations to PNG files."
    ),
)

Custom Agents with Registered Replies

AutoGen allows deep customization through registered replies. You can inject custom logic that triggers before or after an agent's default reply generation, enabling validation loops, logging, or custom routing.

import autogen
from typing import Dict

config_list = [{"model": "gpt-4-turbo", "api_key": "your-key"}]

assistant = autogen.AssistantAgent(
    name="ValidatedAssistant",
    llm_config={"config_list": config_list},
)

def validate_output_before_sending(
    agent, messages, sender, config
) -> tuple:
    """Custom reply function: validate the assistant's output before sending"""
    if len(messages) > 0:
        last_message = messages[-1]
        content = last_message.get("content", "")
        
        # Check for common issues
        if len(content) < 50:
            return True, {
                "role": "user",
                "content": (
                    "Your response was too short. Please provide a more "
                    "detailed answer with at least 50 characters."
                ),
            }
        if "I apologize" in content[:100]:
            return True, {
                "role": "user",
                "content": (
                    "Don't apologize. Just provide the correct answer directly."
                ),
            }
    
    return True, None  # proceed with normal reply

# Register the validation function
assistant.register_reply(
    autogen.ConversableAgent,
    validate_output_before_sending,
    position=0,  # run this BEFORE the default reply function
)

user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="NEVER",
)

user_proxy.initiate_chat(
    assistant,
    message="Explain the CAP theorem in distributed systems.",
)

CrewAI vs AutoGen: Head-to-Head Comparison

Philosophical Differences

The two frameworks embody different design philosophies:

• CrewAI treats agents as workers in a company. You define roles, assign tasks, and the crew executes them in a predefined sequence or hierarchy. It's intuitive for developers familiar with project management concepts.
• AutoGen treats agents as participants in a conversation. Communication is the central primitive, and emergent behavior arises from agent interactions. It's more flexible but requires more careful conversation design.

Comparison Table

When to Choose CrewAI

• You have well-defined workflows where the sequence of steps is known
• Your team thinks in terms of roles and responsibilities
• You need rapid prototyping with minimal boilerplate
• You're building content generation pipelines (research → write → edit → publish)
• You want predictable outputs with clear task boundaries

When to Choose AutoGen

• Your task involves heavy code generation and execution
• You need dynamic, adaptive workflows where the plan emerges from conversation
• You want multiple specialized agents interacting freely
• You require sandboxed code execution for safety
• You're comfortable with conversation design and emergent behavior patterns

Advanced Patterns and Best Practices

1. Start Simple, Then Scale

Begin with two agents before building complex crews or group chats. A researcher + writer pair in CrewAI or an assistant + user proxy pair in AutoGen will reveal the core interaction patterns without overwhelming complexity. Add agents only when you observe genuine bottlenecks or quality gaps.

# Good: Start with minimal agents
crew = Crew(agents=[researcher, writer], tasks=[task1, task2])

# Bad: Prematurely complex setup
crew = Crew(agents=[a1, a2, a3, a4, a5, a6], tasks=[t1, t2, t3, t4, t5, t6, t7])

2. Craft Detailed Agent System Messages

In both frameworks, the quality of agent instructions directly determines output quality. Invest time in writing precise role descriptions (CrewAI backstories) or system messages (AutoGen). Include:

• Specific behavioral rules — "If uncertain, state your uncertainty rather than fabricate"
• Output format requirements — "Always include a code block with runnable Python"
• Constraints — "Do not use external APIs without explicit permission"
• Examples — one or two concrete examples of desired behavior

3. Implement Validation Loops

Never trust a single agent's output blindly. Always include a reviewer or critic agent that checks the work before it reaches the end user. This is one of the highest-leverage patterns in multi-agent design.

# CrewAI validation pattern
reviewer = Agent(
    role="Content Reviewer",
    goal="Verify factual accuracy and logical coherence of all outputs",
    backstory="Meticulous editor who catches errors others miss.",
)

review_task = Task(
    description="Review the writer's output for factual errors and logical gaps.",
    expected_output="Either approval or a list of specific corrections needed.",
    agent=reviewer,
)

crew = Crew(
    agents=[researcher, writer, reviewer],
    tasks=[research_task, writing_task, review_task],
    process=Process.sequential,
)

4. Manage Token Budgets Actively

Multi-agent conversations can consume tokens rapidly. Set explicit limits:

• In AutoGen, use max_consecutive_auto_reply on UserProxyAgent and max_round on GroupChat
• In CrewAI, control verbosity with the verbose parameter and limit task complexity
• Monitor and log token usage in development — costs can multiply quickly with 4+ agents

# AutoGen: strict conversation limits
user_proxy = autogen.UserProxyAgent(
    name="user",
    max_consecutive_auto_reply=3,  # stop after 3 auto-replies
)

groupchat = autogen.GroupChat(
    agents=[agent1, agent2, agent3],
    max_round=10,  # hard limit on conversation turns
)

# CrewAI: control logging verbosity
crew = Crew(
    agents=[agent1, agent2],
    tasks=[task1, task2],
    verbose=1,  # 0=silent, 1=progress, 2=full debug
)

5. Use the Right Model for Each Agent

Not all agents need GPT-4. Assign models based on task complexity:

• Manager/Planner agents — GPT-4 or Claude Opus (strong reasoning needed)
• Simple execution agents — GPT-3.5 or Claude Haiku (cost-effective for straightforward tasks)
• Code generation agents — GPT-4 or specialized code models
• Critic/Reviewer agents — Can often use cheaper models effectively

# CrewAI: different models per agent
from langchain_openai import ChatOpenAI

gpt4 = ChatOpenAI(model="gpt-4-turbo")
gpt35 = ChatOpenAI(model="gpt-3.5-turbo")

researcher = Agent(role="Researcher", llm=gpt4, ...)  # complex reasoning
formatter = Agent(role="Formatter", llm=gpt35, ...)   # simple formatting

# AutoGen: per-agent configuration
assistant = autogen.AssistantAgent(
    name="Coder",
    llm_config={
        "config_list": [{"model": "gpt-4-turbo", "api_key": "key"}],
        "temperature": 0.1,
    },
)

reviewer = autogen.AssistantAgent(
    name="Reviewer",
    llm_config={
        "config_list": [{"model": "gpt-3.5-turbo", "api_key": "key"}],
    },
)

6. Handle Errors Gracefully

Multi-agent systems can fail in subtle ways — infinite conversation loops, malformed outputs, API errors. Implement defensive patterns:

# AutoGen: custom termination condition
def is_conversation_complete(agent, messages, sender, config):
    """Check if the conversation has reached a valid conclusion"""
    for msg in messages[-3:]:
        content = str(msg.get("content", ""))
        if "TASK_COMPLETE" in content or "FINAL_ANSWER" in content:
            return True, None
    return True, {"role": "user", "content": "Please provide your final answer now."}

assistant.register_reply(
    autogen.ConversableAgent,
    is_conversation_complete,
    position=1,
)

# CrewAI: try-except for task execution
try:
    result = crew.kickoff()
except Exception as e:
    print(f"Crew execution failed: {e}")
    # Implement fallback or retry logic

7. Combine Frameworks Strategically

The frameworks are not mutually exclusive. Advanced use cases can benefit from combining them:

• Use AutoGen for code-heavy exploration and CrewAI for structured report generation
• Wrap AutoGen conversations as tools within CrewAI agents
• Use CrewAI for the top-level workflow and AutoGen for subtasks requiring dynamic code execution

Real-World Use Case: Automated Code Review Pipeline

Let's build a complete code review system that showcases both frameworks' strengths. We'll use AutoGen for the dynamic code analysis portion and CrewAI for the structured reporting workflow.

Part 1: AutoGen for Code Analysis

import autogen
import os

config_list = [{"model": "gpt-4-turbo", "api_key": os.environ["OPENAI_API_KEY"]}]

# Code analyzer agent
code_analyzer = autogen.AssistantAgent(
    name="CodeAnalyzer",
    system_message=(
        "You are a senior code reviewer. When given Python code, analyze it for:\n"
        "1. Security vulnerabilities (SQL injection, unsafe deserialization, etc.)\n"
        "2. Performance issues (O(n²) algorithms, memory leaks, inefficient patterns)\n"
        "3. Style violations (PEP 8)\n"
        "4. Test coverage gaps\n"
        "Provide specific, actionable recommendations with line numbers where possible."
    ),
    llm_config={"config_list": config_list, "temperature": 0.1},
)

# Code executor to run the code and capture any runtime errors
executor = autogen.UserProxyAgent(
    name="CodeRunner",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=3,
    code_execution_config={
        "work_dir": "code_review_workspace",
        "use_docker": True,
        "timeout": 30,
    },
)

# Run analysis on submitted code
sample_code = '''
import sqlite3

def get_user_by_id(user_id):
    conn = sqlite3.connect("users.db")
    query = f"SELECT * FROM users WHERE id = {user_id}"
    cursor = conn.execute(query)
    return cursor.fetchall()

def process_data(items):
    result = []
    for i in range(len(items)):
        for j in range(len(items)):
            result.append(items[i] * items[j])
    return result
'''

executor.initiate_chat(
    code_analyzer,
    message=(
        f"Analyze this Python code for issues and suggest improvements:\n\n"
        f"python\n{sample_code}\n\n\n"
        "After analysis, write an improved version of the code that fixes all identified issues."
    ),
)

Part 2: CrewAI for Report Generation

from crewai import Agent, Task, Crew, Process

# Take the AutoGen output and build a structured report
report_writer = Agent(
    role="Technical Report Writer",
    goal="Transform code review findings into structured, actionable reports",
    backstory=(
        "You specialize in creating clear, prioritized code review reports "
        "that engineering teams can act on immediately."
    ),
    verbose=True,
)

categorizer = Agent(
    role="Issue Categorizer",
    goal="Classify code issues by severity and type",
    backstory=(
        "You are methodical and precise. You categorize every issue as "
        "Critical, High, Medium, or Low severity based on impact and exploitability."
    ),
    verbose=True,
)

categorize_task = Task(
    description=(
        "Take the raw code analysis output and categorize every finding into:\n"
        "- Critical: security vulnerabilities that could lead to data loss\n"
        "- High: performance issues causing significant slowdown\n"
        "- Medium: style violations and minor inefficiencies\n"
        "- Low: cosmetic improvements\n"
        "Output a structured JSON with categories and findings."
    ),
    expected_output="JSON object with categorized findings",
    agent=categorizer,
)

report_task = Task(
    description=(
        "Using the categorized findings, create a professional code review report "
        "with: 1) Executive Summary, 2) Critical Findings section, "
        "3) Recommendations ordered by priority, 4) Suggested code fixes."
    ),
    expected_output="Markdown report ready for team distribution",
    agent=report_writer,
)

report_crew = Crew(
    agents=[categorizer, report_writer],
    tasks=[categorize_task, report_task],
    process=Process.sequential,
    verbose=2,
)

# The analysis_result from AutoGen feeds into this crew
final_report = report_crew.kickoff()
print(final_report)

Conclusion

CrewAI and AutoGen represent two powerful but philosophically distinct approaches to multi-agent AI systems. CrewAI excels when you have well-defined workflows and want to map human team structures directly to AI agents — its role-based, task-oriented model makes it intuitive and quick to deploy for content pipelines, research workflows, and structured automation. AutoGen shines in dynamic, code-heavy environments where conversation-driven problem-solving and native code execution provide a decisive advantage — it's the go-to choice for exploratory analysis, iterative coding tasks, and scenarios requiring emergent agent collaboration.

The choice between them isn't absolute. Smart developers understand both frameworks' strengths and often combine them — using AutoGen's code execution capabilities within CrewAI's structured orchestration, or employing CrewAI's clean task model to organize outputs from AutoGen's free-form agent conversations. The key takeaway is that multi-agent architectures are now practical, accessible, and production-ready. By distributing cognitive work across specialized agents with clear roles, validation loops, and appropriate model selection, you can build AI systems that are dramatically more capable, reliable, and cost-effective than any single-prompt approach. Start small, iterate on agent instructions, implement validation patterns, and scale deliberately — the compound AI revolution is here, and these frameworks are your primary toolset.