I Ditched Google ADK for LangGraph | Maybe-Ray
I Ditched Google ADK for LangGraph
25 May, 2026
LangGraph is by far the best framework I've used for creating AI Agents. The framework provides complete control over the execution of individual Agents and the state that flows through them, which you frankly don't get from the Google Agent Development Kit (ADK).
Jumping off from the 5-Day AI Agents Intensive Course with Google on Kaggle, I built the prototype for Ikka, a Zimbabwean news aggregation website using the Google ADK. The trouble with the Google framework began when I needed to implement looping for my editor Agent.
The documentation for the ADK is very dense and, at the time, did not provide a clear way of mixing sequential and looping execution. I spent hours over many weekends trying to find information on how to do certain things, such as logging the state of my Agents after every call or getting my project to run as a script not tied to Google Cloud. The documentation seemed more focused on explaining how the individual parts were linked together than on giving examples. Google also collects quite a bit of telemetry data, and setting up a Google Vertex account to use the Gemini 3 models was a hassle.
To illustrate my frustrations with the framework, I inserted a code example taken from a section in my main loop. The code implements retry logic and Exception handling for cases where an error occurs when calling the LLM, such as pydantic JSON validation and network errors.
while attempt max_retries and not success:<br>attempt += 1<br>print(f"Starting attempt {attempt} of {max_retries}...")
try:<br># Run the generator<br>async for chunk in runner.run_async(<br>user_id="system_admin",<br>session_id=session_id,<br>new_message=types.Content(<br>role="user",<br>parts=[types.Part.from_text(text=f"Research Topic {topic}")],<br>),<br>):<br>pass # Process chunks if needed
success = True<br>print("Newsletter Processed Successfully.")
except Exception as e:<br># This catches Pydantic validation errors or API timeouts<br>print(f"Attempt {attempt} failed with error: {e}")<br>if attempt == max_retries:<br>print("Max retries reached. Manual intervention required.")<br>else:<br>await asyncio.sleep(5) # Brief pause before retrying
At first glance, it is hard to understand what is going on if you are not familiar with async Python. The code would take me an hour or two to fully understand what is happening.
Now this is the same code in LangGraph; the OutputParserException is for when the LLM returns JSON that does not fit a certain structure.
workflow.add_node(<br>"Research_Agent",<br>Research_Agent(data),<br>retry_policy=RetryPolicy(max_attempts=3, retry_on=OutputParserException),
The LangGraph example above has some problems not mentioned. The biggest one is that I have to repeat the code below for every Agent I have. This does not take away from the fact that it is easy to reason about at a glance what the LangGraph code is doing compared to the Google ADK one.
My thoughts on LangGraph<br>If you have ever moved from TensorFlow to PyTorch, then you already know the feeling of moving away from a framework that has a high level of abstraction to one that gives you more flexibility and freedom when it comes to expressing a problem.
After going through the growing pains of adjusting to the new API, you realise that LangGraph is far easier to work with than the Google ADK.
Here is what I liked about LangGraph:
The way to represent the flow of the program as a state change made reasoning about what I was doing easier.
The Documentation is easy to read and understand.
Flexibility and control over what gets called when and how. This allows me to have complete control over the control flow of my program.
For some reason, removing an extra layer of abstraction and giving the programmer more room on how data should flow makes things a lot easier. Like the first time I switched to PyTorch, the freedom of setting up my own training loops and having control of the forward pass helped me make more complex models.
LangGraph has the top spot for me currently in creating AI Agents, the graph-based design with state management made creating feedback loops and any random design choice I wanted easier.
Despite all the negative talk about the Google ADK, there were things that I enjoyed about the:
Pre-built flows for different situations and patterns such as their Sequential, parallel and loop Agents.
Easy integration of Google-related tools, such as search.
State management and formatting are all handled for you
Conclusion<br>Overall, LangGraph represents the problem of orchestrating AI Agents and state management better than the Google ADK. This, coupled with good documentation, makes it far the better option.
I have discovered that the Google ADK 2.0 will support Graph-based workflows and thus fixes some of the issues I initially had with the framework.