controlling the exact content that goes into the LLM, as well as running the appropriate steps to generate relevant content.

Agentic systems consist of both workflows and agents (and everything in between)

Most agentic frameworks

a set of agent abstractions.

Workflows are systems where LLMs and tools are orchestrated through predefined code paths.

Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

Nearly all of the “agentic systems” we see in production are a combination of “workflows” and “agents”.

When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed

Otherwise, a deterministic solution may suffice.

systems as being agent-like to different degrees.

The number one response by far was “performance quality”

The LLM messes up.

the model is not good enough

the wrong (or incomplete) context is being passed to the model.

very frequently the second use case

Incomplete or short system messages

Vague user input

Not having access to the right tools

Poor tool descriptions

Not passing in the right context

Poorly formatted tool responses

This includes both controlling the exact content that goes into the LLM, as well as running the appropriate steps to generate relevant content.

makes it harder to control exactly what is being passed to the LLM is just getting in your way

Nodes represent units of work, while edges represent transitions

so while the structure of the graph is represented in a declarative manner, the inner functioning of the graph’s logic is normal, imperative code

LangGraph is a low level orchestration framework for building agentic systems.

As your system becomes more agentic, it will become less predictable.

Workflow frameworks offer a high ceiling, but come with a high floor

Agent frameworks are low floor, but low ceiling

Frameworks like Agents SDK (and original LangChain, CrewAI, etc) are neither declarative or imperative - they are just abstractions.

Most agent frameworks contain an agent abstraction. They usually start as a class that involves a prompt, model, and tools

This is the danger of agent abstractions.

One of those original abstractions from two years ago was an agent class that took in a model, prompt, and tools. This isn’t a new concept. It didn’t provide enough control back then, and it doesn’t now.

best way to think about these agent abstractions is like Keras.

The key part of multi agent systems is how they communicate.

Again - agentic systems are not just workflows, or just an agent. They can be - and often are - a combination of the two.

Frameworks are generically useful because they contain useful abstractions which make it easy to get started and provide a common way for engineers to build, making it easier to onboard and maintain projects

LangGraph provides production ready storage to enable multi-turn experiences (threads) .

(e.g. remembering things across conversations)

LangGraph provides production ready storage for cross-thread memory .

human-in-the-loop component

feedback from the user, approving a tool call, or editing tool call arguments

built in support for this .

debugging and observability

fault tolerance

Rather than tweaking prompts manually by hand, it can sometimes be easier to define an evaluation dataset and then automatically optimize your agent based on this.

dspy is the best framework for this currently.

If you do use a framework, ensure you understand the underlying code

Incorrect assumptions about what's under the hood are a common source of customer error.

For some applications, this tool calling loop will be enough

workflows will just be simpler, cheaper, faster, and better

finding the simplest solution possible

Agentic systems often trade latency and cost for better task performance

Otherwise, a deterministic solution may suffice.

simple tool calling loop will be enough

this will likely only be true if you are using a model trained/finetuned/RL’d on lots of data that is specific to your use case

If you can train a SOTA model on your specific task - then yes, you probably don’t need a framework that enables arbitrary workflows, you’ll just use a simple tool calling loop. In this case, agents will be preferred over workflows.

they're all being optimized for terminal

“declarative vs imperative”

parts

But Agents SDK is NOT an imperative framework. It’s an abstraction

I would argue that having to learn and work around Agents SDK abstractions is, at this point in time, worse than having to learn LangGraph abstractions

Largely because the hard thing about building reliable agents is making sure the agent has the right context, and Agents SDKs obfuscates that WAY more than LangGraph.

Agents SDK, Google's ADK, LangChain, Crew AI, LlamaIndex, Agno AI, Mastra, Pydantic AI, AutoGen, Temporal, SmolAgents, DSPy.

The hard part of building reliable agentic systems is making sure the LLM has the appropriate context at each step

content

appropriate steps

LangGraph is best thought of as a orchestration framework

both declarative and imperative APIs