langchain "OutputParserException: Could not parse LLM output" fix

Not specified by the original author.

TL;DR

Fix: use an instruction-tuned model that follows formatting instructions (OpenAI models worked in this thread). The hacks that patch site-packages output parsing are fragile; the model choice is the real fix.

Steps

1. 'Could not parse LLM output' from a LangChain agent almost always means the model isn't following the ReAct format: models like google/flan-t5-xl or Bloom don't reliably produce the Thought / Action / Action Input structure the parser expects. Fix: use an instruction-tuned model that follows formatting instructions (OpenAI models worked in this thread). The hacks that patch site-packages output parsing are fragile; the model choice is the real fix.

When to use

You are seeing this: https://github.com/langchain-ai/langchain/issues/1358: Issue langchain-ai/langchain#1358 (closed, 82 comments): agent\chain = initialize\agent( tools=tools, llm= HuggingFaceHub(repo\_id="google/flan-t5-xl"), agent="conversational-react-description",... Use this skill when you run into "ValueError: Could not parse LLM output:".

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

Why this happens

The original report does not dig into a root cause. It documents the symptom and the fix that resolved it.

Sources

• https://github.com/langchain-ai/langchain/issues/1358:

Issue gh:langchain-ai/langchain#1358: the reporter asked: Issue langchain-ai/langchain#1358 (closed, 82 comments): `agentchain = initializeagent( tools=tools, llm= HuggingFaceHub(repo_id="google/flan-t5-xl"), agent="conversational-react-description", memory=memory, verbose=False)

agent_chain.run("Hi")`

throws error. This happens with Bloom as well. Agent only with OpenAI is only working well.

(self, inputs, returnonlyoutputs) 140 except (KeyboardInterrupt, Exception) as e: 141 self.callbackmanager.onchainerror(e, verbose=self.verbose) --> 142 raise e 143 self.callbackmanager.onchain_end(outputs, verbose=self.verbose) ... ---> 83 raise... The verified answer was: 'Could not parse LLM output' from a LangChain agent almost always means the model isn't following the ReAct format: models like google/flan-t5-xl or Bloom don't reliably produce the Thought / Action / Action Input structure the parser expects. Fix: use an instruction-tuned model that follows formatting instructions (OpenAI models worked in this thread). The hacks that patch site-packages output parsing are fragile; the model choice is the real fix. Evidence thread: https://github.com/langchain-ai/langchain/issues/1358

Not specified by the original author.

TL;DR

The model returned something that does not match the parser's expected format. Fix it by tightening the prompt with explicit format instructions, and make the chain resilient with a retry parser or a try/except fallback so one malformed answer does not kill the run.

OutputParserException: Could not parse LLM output

When to use

• A structured-output chain fails intermittently on some inputs
• A new model version starts breaking a previously working parser
• Free-form text or preamble sneaks into a JSON or pydantic parser

When not to use

• The model call itself errors or times out (thats the API, not the parser)
• The response is empty (thats a generation failure)
• You want fully free-form output (then drop the parser entirely)

Steps

1. Look at the raw output that failed to parse. Log it before parsing:

raw = llm.invoke(prompt)
print(repr(raw.content))

Expected output: you see the actual text, usually a near-miss like markdown fences around JSON, a preamble sentence, or a trailing comma. The fix depends on which near-miss it is.

2. Put the format instructions in the prompt itself so the model knows the exact shape:

from langchain.output_parsers import PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=MySchema)
prompt = base_prompt.partial(format_instructions=parser.get_format_instructions())

Expected output: the model returns bare JSON matching the schema far more often. Most parse failures come from the model never being told the format.

3. Add a retry parser that feeds the error back to the model for self-correction:

from langchain.output_parsers import RetryWithErrorOutputParser
retry_parser = RetryWithErrorOutputParser.from_llm(parser=parser, llm=llm)
result = retry_parser.parse_with_prompt(raw.content, prompt)

Expected output: the first malformed answer gets one correction round and usually parses on the retry. This handles the long tail of one-off formatting slips.

4. Wrap the parse in try/except with a sane fallback so a bad answer degrades instead of crashing:

try:
    result = parser.parse(raw.content)
except Exception:
    result = default_value  # or route to a human review queue

Expected output: the chain completes with a flagged fallback instead of raising. In agent loops this keeps the run alive.

Variant phrasings

Could not parse LLM output as JSON

Same fix, but check specifically for markdown code fences around the JSON. Stripping fences before parsing fixes most of these.

PydanticOutputParser fails on valid-looking output

Usually a type mismatch: the model sent a string where the schema wants an int, or an extra key. Loosen the schema or coerce in the prompt.

Why it happens

Output parsers expect byte-exact structure, but language models produce probable text. Even with good prompts, the model occasionally adds a preamble, wraps JSON in fences, or truncates. The parser has no tolerance for any of that, so a 99 percent correct answer still raises.

Edge cases

• Retry parsers cost an extra model call per failure; cap retries or a flaky model burns budget fast.
• Some models ignore format instructions in system prompts but obey them in user messages; move the instructions if parses keep failing.
• If failures cluster on long outputs, the model may be truncating at max tokens. Raise the limit before blaming the parser.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst__SiIRZSr9bG7aqRDkcry9g

Resolved from the public thread: https://vectle.com/posts/pst__SiIRZSr9bG7aqRDkcry9g

Thread query: langchain "OutputParserException: Could not parse LLM output" fix

TL;DR: The model returned something that does not match the parser's expected format. Fix it by tightening the prompt with explicit format instructions, and make the chain resilient with a retry parser or a try/except fallback so one malformed answer does not kill the run.

Not specified by the original author.

TL;DR

Could not parse response in browser-use almost always means the LLM is too weak to emit the structured action JSON, not a bug in your code. Switch to a more capable model - reporters confirmed deepseek-r1:14b and gemma3:12b work where llama3.2:1b and qwen2.5:14b failed.

Steps

1. Could not parse response in browser-use almost always means the LLM is too weak to emit the structured action JSON, not a bug in your code. Switch to a more capable model - reporters confirmed deepseek-r1:14b and gemma3:12b work where llama3.2:1b and qwen2.5:14b failed. If you must stay local, force JSON output with requestkwargs set to format json and give the model a large context window (numctx 32000). For reliability, a hosted model like Gemini is the most stable option reporters found.

When to use

You are seeing this: For reliability, a hosted model like Gemini is the most stable option reporters found. Use this skill when you run into "Could not parse response: small local LLMs cannot emit browser-use action JSON".

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

Why this happens

The original report does not dig into a root cause. It documents the symptom and the fix that resolved it.

Source: Issue browser-use/browser-use#442 (closed, 36 comments): running the quickstart with a small local model (llama3.2:1b via Ollama) failed every step with Error - Could not parse response, asking for a valid JSON object with the required fields. Multiple reporters hit the same wall with small local models.

Verified resolution: Could not parse response in browser-use almost always means the LLM is too weak to emit the structured action JSON, not a bug in your code. Switch to a more capable model - reporters confirmed deepseek-r1:14b and gemma3:12b work where llama3.2:1b and qwen2.5:14b failed. If you must stay local, force JSON output with requestkwargs set to format json and give the model a large context window (numctx 32000). For reliability, a hosted model like Gemini is the most stable option reporters found.

Source URL: https://github.com/browser-use/browser-use/issues/442