Upjack vs. LangChain vs. CrewAI: A Builder's Comparison

Three frameworks. Three fundamentally different architectures. Three different answers to the same question: how do you build AI-powered applications?

LangChain is a Python library for composing LLM calls into chains and agents. CrewAI is a role-based framework for orchestrating multiple AI agents as a team. Upjack is a declarative application framework where apps are defined as JSON schemas and markdown skills, with no imperative code required.

They are not interchangeable. The right choice depends on what you’re building, who will maintain it, and how much engineering you want in the loop. Here’s an honest comparison.

Architecture: Three Models

LangChain: Imperative, Code-First

LangChain is a toolkit. You write Python code that defines how LLM calls connect, what data flows between them, how retrieval works, and how outputs get parsed. The developer controls every step. Prompt templates, chain composition, retriever configuration, output parsing, error handling, all expressed in Python.

The architecture model is imperative: you tell the system exactly what to do and in what order. Each chain is a sequence of operations. Each agent is a Python class with tool definitions and routing logic. The code IS the application.

This gives maximum flexibility. If you need a novel agent architecture with custom components, LangChain gives you the primitives to build it. The tradeoff is that every application requires an engineer to build, an engineer to modify, and an engineer to operate.

CrewAI: Role-Based, Multi-Agent

CrewAI introduces a higher-level abstraction: crews. You define AI agents with specific roles (researcher, analyst, writer), assign them tasks, and the framework orchestrates their collaboration. Each agent has a backstory, a goal, and a set of tools. Tasks define what needs to happen. The crew manages the workflow between agents.

The architecture model is role-based: you decompose work into roles and tasks, and the framework handles inter-agent communication, task delegation, and result aggregation. It’s designed specifically for scenarios where multiple agents need to collaborate: research pipelines, content production workflows, analysis teams.

This is more structured than LangChain’s raw primitives, but still code-first. Defining agents, crews, and tasks requires Python. The developer controls the roles and orchestration patterns.

Upjack: Declarative, Schema-Driven

Upjack takes a fundamentally different approach. Applications are not coded; they are declared. A JSON manifest defines the app. Entity schemas define the data model. Markdown skills define the behavioral logic. Context files provide background knowledge. MCP server connections provide tools.

The architecture model is declarative: you describe what the application knows and what it should do. The runtime handles execution, tool routing, state management, and error recovery. The application lives in structured documents (JSON and markdown), not in code.

This is the Business-as-Code model made executable. The same artifacts that encode business knowledge ARE the running application. Change a skill file, and the application’s behavior changes. No recompilation, no deployment pipeline.

The Comparison Table

Dimension	LangChain	CrewAI	Upjack
Architecture	Imperative chains and agents	Role-based crews and tasks	Declarative schemas and skills
Primary language	Python (TS available)	Python	JSON + Markdown (no code)
Learning curve	High: requires Python proficiency and LLM architecture knowledge	Medium: requires agent pattern knowledge and Python	Low: requires JSON schema and natural language writing
Who builds apps	AI engineers	AI engineers	Domain experts + engineers
Who maintains apps	Engineers only	Engineers only	Domain experts can modify skills and schemas
Flexibility	Maximum: full control over every component	High: custom agents and tools within crew patterns	Moderate: framework handles orchestration internals
Multi-agent	Manual orchestration via code	First-class crew orchestration	Single agent with multi-tool routing
Tool integration	Custom Python tool functions	Custom Python tool functions	MCP server connections (standardized)
Community size	Very large (multi-year head start)	Growing (strong multi-agent focus)	Smaller (production-oriented)
Best for	Custom agent architectures, novel LLM pipelines	Multi-agent collaboration, research workflows	Domain applications, business process automation
Ownership model	Code owned by engineering	Code owned by engineering	Artifacts owned by business + engineering

When to Use LangChain

LangChain is the right choice when engineering control is the priority.

You’re building a novel retrieval-augmented generation pipeline with custom chunking strategies and reranking. You need fine-grained control over prompt templates across different model providers. You’re composing complex chains where the output of one LLM call determines the structure of the next. Your team has strong Python engineers who are comfortable with LLM internals.

LangChain excels at infrastructure-level AI work. Custom embeddings pipelines, novel agent architectures, complex tool-use patterns that don’t fit standard frameworks. The ecosystem is massive, with LangChain integrations for nearly every API, database, and service.

Where LangChain struggles: applications that non-engineers need to own. Every LangChain app is a Python codebase. When the business process changes, you need an engineer to change the code. When the prompt needs tuning, you need an engineer to update the template. The knowledge lives in code, which means it lives in the engineering team’s backlog.

When to Use CrewAI

CrewAI is the right choice when multi-agent collaboration is the core pattern.

You’re building a research pipeline where one agent gathers data, another analyzes it, and a third writes the report. You’re automating a content workflow where a researcher, editor, and publisher work in sequence. You want to model your AI workflow as a team of specialists who hand off work to each other.

The crew metaphor maps well to workflows that humans already think of as team-based. If you naturally describe the work as “the researcher finds the data, the analyst scores it, and the writer produces the output,” CrewAI’s architecture matches your mental model.

Where CrewAI struggles: applications where the business team needs to modify behavior. Like LangChain, crews are defined in Python. The roles, tasks, and orchestration patterns are code. Non-engineers can’t modify how agents collaborate without developer support. And CrewAI is specifically designed for multi-agent patterns; if your application is a single-agent domain system, the crew abstraction adds overhead without benefit.

When to Use Upjack

Upjack is the right choice when business ownership is the priority.

You’re building an AI application that domain experts need to understand, validate, and modify. The business processes change quarterly and you can’t wait for engineering sprints to update the AI’s behavior. You want the people closest to the work to control how the AI works. You’re implementing Business-as-Code and need the artifacts to be directly executable.

Upjack excels at domain applications: customer onboarding, lead qualification, operations automation, compliance monitoring, workflow management. Applications where the logic comes from business expertise and the competitive advantage comes from encoding that expertise faster than competitors.

Where Upjack struggles: novel agent architectures that require fine-grained control over LLM internals. If you need custom chain composition, novel prompting strategies, or experimental multi-agent patterns, Upjack’s declarative model abstracts away the control you need. The framework handles orchestration, which is a feature when you want simplicity and a limitation when you want control.

The Composition Pattern

These frameworks don’t have to be mutually exclusive.

The pattern NimbleBrain uses on complex engagements: Upjack handles the business application layer (schemas, skills, domain logic, user interaction). MCP servers handle the tool layer, and those MCP servers can use LangChain internally for specialized processing pipelines. A document analysis MCP server might use LangChain’s retrieval chains. A data enrichment MCP server might use CrewAI for multi-step research.

Upjack connects to MCP servers. MCP servers use whatever technology fits the task. The business layer stays declarative and business-owned. The infrastructure layer uses the right tool for each job.

This separation is clean because of how MCP works. The Upjack application doesn’t know or care what technology the MCP server uses internally. It sends a request, gets a response. The business team owns the Upjack layer. The engineering team owns the MCP server layer. Each team controls what they’re best at.

NimbleBrain’s Honest Take

We built Upjack, so we’re biased. Here’s where we try to be honest about it.

LangChain has a massive ecosystem advantage. More integrations, more examples, more community support, more Stack Overflow answers. If you hit a problem with LangChain, someone has probably solved it before. Upjack’s community is smaller and more focused.

CrewAI has a multi-agent orchestration advantage. If your core problem is coordinating multiple specialized agents, CrewAI’s crew abstraction is purpose-built for that. Upjack routes to tools, not to other agents.

Upjack’s advantage is ownership and accessibility. Non-engineers can read, validate, and modify Upjack applications. That changes who participates in AI development, how fast iterations happen, and whether the organization can operate the system after the builders leave. On every engagement, we optimize for Escape Velocity, the point where the client operates independently. Upjack makes that architecturally possible because the artifacts are the system, and the artifacts are readable by anyone.

If we’re being direct: use LangChain if you have AI engineers and want maximum control. Use CrewAI if multi-agent orchestration is your core problem. Use Upjack if you want your business team to own and evolve the AI application. For a deeper introduction to Upjack’s architecture, see What Is Upjack. To try it yourself, see Building Your First Upjack App.