Hey r/LangChain,

The problem with LangGraph agents in production

After 10+ prompt iterations, my LangGraph agent still behaves differently every time for the same task.

Ever experienced this with LangGraph agents?

• Your agent calls a tool through LangGraph, but it doesn't work as expected: gets fewer results than needed, returns irrelevant items

• Back to system prompt tweaking: "If the search returns less than three results, then...," "You MUST review all results that are relevant to the user's instruction," etc.

• However, a slight change in one instruction can break logic for other scenarios. Endless prompt tweaking cycle.

• LangGraph's routing works great for predetermined paths, but struggles when you need reactions based on actual tool output content

• As a result, custom logic spreads everywhere in prompts and custom tools. No one knows where specific scenario logic lives.

Couldn't ship to production because behavior was unpredictable - same inputs, different outputs every time. Traditional LangGraph approaches like prompt tweaking and custom tool wrappers felt wrong.

What I built instead: Agent Control Layer

I created a library that eliminates prompt tweaking hell and makes LangGraph agent behavior predictable.

Here's how simple it is: Define a rule:

target_tool_name: "web_search"
trigger_pattern: "len(tool_output) < 3"
instruction: "Try different search terms - we need more results to work with"

Then, literally just add one line to your LangGraph agent:

# LangGraph agent
from agent_control_layer.langgraph import build_control_layer_tools
# Add Agent Control Layer tools to your existing toolset
TOOLS = TOOLS + build_control_layer_tools(State)

That's it. No more prompt tweaking, consistent behavior every time.

The real benefits

Here's what actually changes:

• Centralized logic: No more hunting through LangGraph prompts and custom tools to find where specific behaviors are defined

• Version control friendly: YAML rules can be tracked, reviewed, and rolled back like any other code

• Non-developer friendly: Team members can understand and modify agent behavior without touching LangGraph code

• Audit trail: Clear logging of which rules fired and when, making LangGraph agent debugging much easier

Your thoughts?

What's your current approach to inconsistent LangGraph agent behavior?

Agent Control Layer vs prompt tweaking - which team are you on?

What's coming next

I'm working on a few updates based on early feedback:

1. Performance benchmarks - Publishing detailed reports on how the library affects LangGraph agent accuracy, latency, and token consumption

2. Natural language rules - Adding support for LLM-as-a-judge style evaluation, so you can write rules like "if the results don't seem relevant to the user's question" instead of strict Python conditions

3. Auto-rule generation - Eventually, just tell the agent "hey, handle this scenario better" and it automatically creates the appropriate rule for you

What am I missing? Would love to hear your perspective on this approach.