RANA vs CrewAI

from crewai import Agent, Task, Crew, Process

# Define agents
researcher = Agent(
    role='Senior Research Analyst',
    goal='Uncover cutting-edge developments',
    backstory='You are a senior researcher...',
    verbose=True,
    allow_delegation=False,
    tools=[SearchTool(), WebScraperTool()]
)

writer = Agent(
    role='Content Writer',
    goal='Create engaging content',
    backstory='You are a skilled writer...',
    verbose=True,
    allow_delegation=True
)

# Define tasks
research_task = Task(
    description='Research the latest AI trends',
    expected_output='A comprehensive report',
    agent=researcher
)

write_task = Task(
    description='Write an article based on research',
    expected_output='A blog article',
    agent=writer,
    context=[research_task]
)

# Create and run crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()

import { createPipeline } from '@rana/agents';

const { orchestrator, execute } = createPipeline([
  {
    id: 'researcher',
    name: 'Research Analyst',
    capabilities: ['research', 'summarize'],
  },
  {
    id: 'writer',
    name: 'Content Writer',
    capabilities: ['write', 'edit'],
  },
]);

const result = await execute({
  taskId: 'ai-trends-article',
  description: 'Research AI trends and write an article',
  input: { topic: 'AI trends' },
});

from crewai import Crew, Process

# Define multiple agents for parallel work
agent1 = Agent(role='Analyst 1', ...)
agent2 = Agent(role='Analyst 2', ...)
agent3 = Agent(role='Analyst 3', ...)

task1 = Task(description='Analyze market A', agent=agent1)
task2 = Task(description='Analyze market B', agent=agent2)
task3 = Task(description='Analyze market C', agent=agent3)

# CrewAI hierarchical process
crew = Crew(
    agents=[agent1, agent2, agent3],
    tasks=[task1, task2, task3],
    process=Process.hierarchical,  # Not truly parallel
    manager_llm=ChatOpenAI()
)

result = crew.kickoff()

import { createWorkerPool } from '@rana/agents';

const { execute } = createWorkerPool([
  { id: 'analyst-1', name: 'Analyst 1', capabilities: ['analyze'] },
  { id: 'analyst-2', name: 'Analyst 2', capabilities: ['analyze'] },
  { id: 'analyst-3', name: 'Analyst 3', capabilities: ['analyze'] },
]);

// True parallel execution
const results = await execute([
  { taskId: 'market-a', description: 'Analyze market A', input: {} },
  { taskId: 'market-b', description: 'Analyze market B', input: {} },
  { taskId: 'market-c', description: 'Analyze market C', input: {} },
]);

// results = [resultA, resultB, resultC] - all executed in parallel

from crewai import Agent
from crewai_tools import SerperDevTool, WebsiteSearchTool

# Tools require separate crewai_tools package
search_tool = SerperDevTool()
web_tool = WebsiteSearchTool()

agent = Agent(
    role='Researcher',
    goal='Find information',
    backstory='...',
    tools=[search_tool, web_tool],
    verbose=True
)

# Tool execution is handled by the agent
# Custom tools require specific interface implementation

import { createTool, createAgent } from '@rana/agents';

// Simple tool creation
const searchTool = createTool({
  name: 'search',
  description: 'Search the web',
  parameters: { query: { type: 'string' } },
  handler: async ({ query }) => {
    // Your search implementation
    return results;
  },
});

const webTool = createTool({
  name: 'fetch_page',
  description: 'Fetch a webpage',
  parameters: { url: { type: 'string' } },
  handler: async ({ url }) => {
    const res = await fetch(url);
    return res.text();
  },
});

// Use with any agent
const agent = createAgent({
  tools: [searchTool, webTool],
});

from crewai import Agent
from crewai.memory import LongTermMemory, ShortTermMemory

# Memory configuration
agent = Agent(
    role='Assistant',
    goal='Help users',
    backstory='...',
    memory=True,  # Enable memory
    long_term_memory=LongTermMemory(),
    short_term_memory=ShortTermMemory()
)

# Memory is implicit and managed internally
# Limited control over memory operations

import { SharedStateManager, createOrchestrator } from '@rana/agents';

const orchestrator = createOrchestrator({
  conversationHistory: [],
  userPreferences: {},
});

// Explicit state management
await orchestrator.updateState({
  type: 'append',
  key: 'conversationHistory',
  value: { role: 'user', content: 'Hello' },
});

// Transaction support for complex updates
await orchestrator.transaction('update-context', async (state) => {
  state.conversationHistory.push(newMessage);
  state.lastUpdated = Date.now();
  return state;
});

// Subscribe to state changes
orchestrator.subscribeToState((state) => {
  console.log('Memory updated:', state);
});