LangChain callbacks can miss delegated work when callback configuration does not reach a child invocation, while a supervisor can also appear unaware of a failure simply because the sub-agent left it out of its final response. Those are different problems: trace the child run, check each delegation boundary, and verify what the child returns before concluding that callbacks swallowed an error.
Why can LangChain callbacks miss a sub-agent failure?
There is no single “delegation masking” mechanism. Missing callback events, an exception converted into a tool result, and a child failure omitted from the supervisor’s answer arise at different boundaries. A parent-level success event by itself does not prove that every operation performed by a sub-agent succeeded.
As an Amazon Associate I earn from qualifying purchases.
LangChain’s RunnableConfig reference describes callbacks as applying to “this call and any sub-calls (e.g. a Chain calling an LLM).” Its documented propagation model passes child runnable configuration through a ContextVar and merges configuration rather than replacing it. That is the intended behavior for runnable sub-calls, not a guarantee that every custom wrapper or separately invoked agent forwards the configuration correctly.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchCallback setup may not reach the child invocation
Callbacks have separate error events for chains, tools, and language-model calls: on_chain_error, on_tool_error, and on_llm_error. The callback interface also provides a run_id and optional parent_run_id, which let a handler relate a child event to its parent. If logging captures only the outermost event, it may hide where in the run tree an error occurred.
#1 Best Overall
A reported agent path may bypass callback setup
LangChain issue #36395 reports a specific case in which an agent model node used trace=False, bypassing callback setup in the cited RunnableCallable.ainvoke() path. The issue reporter describes it as: “No error is thrown – this is a silent failure where callbacks are never set up.” Treat that as a report about the described code path, not as proof that callbacks fail for all agents or that the behavior persists in every release. The report does not establish its resolution or applicability across versions.
The sub-agent may omit the result the supervisor needs
LangChain’s sub-agent documentation explains that “the supervisor only sees the final output” by default. A sub-agent may call a tool or encounter a problem yet omit the relevant result from its final message. In that case, the supervisor can produce an answer that gives no indication of the child’s work, even if callback propagation was functioning.
How can you tell whether the child failed, the trace is missing, or the result was lost?
Separate the execution record from the message passed back to the supervisor. Use the following sequence to locate the boundary where information disappears.
- Inspect the child run. Look for the child
run_id, itsparent_run_id, the event type, and any error details. Determine whether the child emittedon_tool_error,on_chain_error, oron_llm_error. - Check callback configuration at each delegation boundary. Confirm that the child runnable receives the callback configuration you expect. Standard
RunnableConfigpropagation is documented for sub-calls, but a custom wrapper or a separately invoked agent may need explicit forwarding. - Check the actual invocation path and installed version. If child events are absent, compare your path with the
trace=Falsecase reported in issue #36395. Do not assume that report applies without verifying the code path and version you run. - Identify the error’s handling semantics. Determine whether an ordinary exception propagates, is converted into an error-status tool result, or is instead a control-flow signal such as an interrupt or a command to a parent.
- Inspect the sub-agent’s return contract. Verify that its final message or explicitly returned state contains the success or failure status, relevant tool results, and any other information the supervisor needs.
- Compare the event tree with the supervisor’s response. If the child error appears in the event tree but not the response, investigate the handoff or the supervisor’s synthesis. If child events are absent, investigate configuration and callback setup. If an error became a tool result, inspect how the supervisor handles that result.
This sequence is a diagnostic interpretation of the documented event, propagation, and handoff contracts; it is not a guarantee that every application will expose every event in the same way.
What happens when a tool exception is handled instead of propagated?
LangChain’s ToolErrorMiddleware reference describes error handling as opt-in. A configured handler can turn an exception into content carried by a ToolMessage with error status. If the exception is not handled, it propagates and can halt the run. These outcomes change what reaches the parent: an error represented as a tool result is not the same as an exception that terminates execution.
Interrupts and commands directed to a parent are control-flow signals, not ordinary tool exceptions; the reference says they propagate separately and do not reach on_error. So an absent on_error event alone is not evidence that an exception was swallowed. First establish whether the event was an ordinary exception, an error-status tool result, or control flow.
How should a sub-agent report failures to its supervisor?
Make the handoff explicit. LangChain’s sub-agent guidance recommends specifying the information the sub-agent must return, or passing selected state keys back explicitly through a Command. The return contract should say which outcome and evidence the supervisor needs—not merely ask the child to “report back.”
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problems- Require a clear success or failure status.
- Require relevant tool results and error details when they affect the task.
- Specify which state values the supervisor must receive, and return those values explicitly when appropriate.
A complete handoff improves the supervisor’s view of the work; it does not replace child-level callback instrumentation. Conversely, a complete trace does not guarantee that the supervisor will include the child’s findings in its final answer.
Which boundary should you fix first?
Match the symptom to the mechanism rather than treating every missing failure as a callback bug.
| What you observe | Likely boundary to inspect | What to verify |
|---|---|---|
| Child run exists, but expected callback events are absent | Configuration propagation or callback setup | Whether callbacks reach that child invocation; whether its path resembles the specific trace=False report |
| Child error appears in the event tree, but not in the supervisor’s answer | Sub-agent handoff or supervisor synthesis | Whether the final message or returned state includes the error and relevant result |
| Tool failure appears as a tool result, not a propagated exception | Error handling policy | Whether middleware converted the exception into an error-status ToolMessage |
No on_error event for an interrupt or parent-directed command |
Control-flow handling | Whether the event is a control-flow signal rather than an ordinary exception |
The general callback and handoff behavior above comes from LangChain’s current RunnableConfig, callback, sub-agent, and middleware references. The silent setup omission is narrower: it is reported for the path in issue #36395, and the report does not establish behavior across current releases.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →
