Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

LLM Agents Are Simply Graph – Tutorial for Dummies

zacharyhuang.substack.com

Post reply on HN
Print view View original

31–40 of 82 posts

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#31

Post by godelski »

adamnemecek wrote: post #12
zh2408 wrote: post #10

Earlier quoted context omitted.

Hey, sorry for the confusion. This tutorial is focusing on the low-level internals of how agents are implemented—much like how intelligent large language models still boil down to matrix multiplications at their core.

Despite the memes, this reductivism is not exactly insightful. Like why stop there? Matrix multiplication is just a bunch of dot product. Which in turn is just cos and magnitude. What insights were generated from this?

  > this reductivism is not exactly insightful.
I really agree with this. I think it has been bad for a lot of people's understanding when they have trivialized ML to "just matrix multiplications" (or GMMs). This does not help differentiate AI/ML from... well.. really any data processing algorithm. Matrices are fairly general structures in mathematics and you can formulate almost anything as one. In fact, this is a very common way to parallelize or speed up programs (e.g. numpy vectorization).

We wouldn't call least squares, even a bunch of them, ML nor would we call rasterization or ray tracing. Fundamentally all these things are "just GMMs". It also does not make apparent any differentiation from important distinctions like Linear Networks, CNNs, or Transformers. It brushes off a key element, the activation function, which is necessary for neural nets to do non-linear transformations! And what about the residual units? These are one of the most important factors in enabling Deep Learning. They're "just" addition. So we say it's all just matrix addition since we can convert multiplication to addition?

There is such a thing as oversimplification and I worry that we have hyper-optimized (over-optimized) for this. So I agree, saying they just "boil down to matrix multiplications" is fundamentally misleading. It provides no insight and only serves to mislead people.

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#32

Post by godelski »

zh2408 wrote: post #10
_pdp_ wrote: post #9

It is hard to put a pin on this one because there are so many thing wrong with this definition. There are agent frameworks that are not rebranded workflow tools too. I don't think this article helps explain anything except putting the intended audience in the same box of mind we were stuck since the invention of programming - i.e. it does not help. Forget about boxes and deterministic control and start thinking of er…

Hey, sorry for the confusion. This tutorial is focusing on the low-level internals of how agents are implemented—much like how intelligent large language models still boil down to matrix multiplications at their core.

  > This tutorial is focusing on the low-level internals of how agents are implemented
We have very different definitions of what "low-level" means. Exact opposites in fact. "Low-level" means in the inner workings. Like a low-level language is assembly (some consider C low-level but this is debatable), whereas Python would be high-level.

I don't think this tutorial is "near the metal" of LLMs nor do I think it should be considering it is aimed at "Dummies". Low-level would really need to get into the inner workings of the processing, probing agents, and getting into the weeds.

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#33

Post by godelski »

zh2408 wrote: post #30
godelski wrote: post #28

Earlier quoted context omitted.

Minor comment: do you mean "LLM Agents Are Simply Graphs". Personally, I'd drop the adjective to "LLM Agents are Graphs" as I think it sounds better, but the plural is needed.

Oh, that’s embarrassing ... pardon my poor English, and thanks so much for pointing that out!

Simple mistake and easy to fix :)

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#34

Post by jumploops »

Anthropic[0] and Google[1] are both pushing for a clear definition of an “agent” vs. an “agentic workflow”

tl;dr from Anthropic:

> 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.

Most “agents” today fall into the workflow category.

The foundation model makers are pushing their new models to be better at the second, “pure” agent, approach.

In practice, I’m not sure how effective the “pure” approach will work for most LLM-assisted tasks.

I liken it to a fresh intern who shows up with amnesia every day.

Even if you tell them what they did yesterday, they’re still liable to take a different path for today’s work.

My hunch is that we’ll see an evolution of this terminology, and agents of the future will still have some “guiderails” (note: not necessarily _guard_rails), that makes their behavior more predictable over long horizons.

[0]https://www.anthropic.com/engineering/building-effective-age...

[1]https://www.youtube.com/watch?v=Qd6anWv0mv0

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#35

Post by zh2408 »

godelski wrote: post #32
zh2408 wrote: post #10

Earlier quoted context omitted.

Hey, sorry for the confusion. This tutorial is focusing on the low-level internals of how agents are implemented—much like how intelligent large language models still boil down to matrix multiplications at their core.

> This tutorial is focusing on the low-level internals of how agents are implemented We have very different definitions of what "low-level" means. Exact opposites in fact. "Low-level" means in the inner workings. Like a low-level language is assembly (some consider C low-level but this is debatable), whereas Python would be high-level. I don't think this tutorial is "near the metal" of LLMs nor do I think it should b…

By low-level, it is with respect to the agent interface.

The original purpose is to help people understand how the inner agent framework is internally implemented, like those:

OpenAI Agents: https://github.com/openai/openai-agents-python/blob/48ff99bb... Pydantic Agents: https://github.com/pydantic/pydantic-ai/blob/4c0f384a0626299... Langchain: https://github.com/langchain-ai/langchain/blob/4d1d726e61ed5... LangGraph: https://github.com/langchain-ai/langgraph/blob/24f7d7c4399e2...

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#36

Post by zh2408 »

jumploops wrote: post #34

Anthropic[0] and Google[1] are both pushing for a clear definition of an “agent” vs. an “agentic workflow” tl;dr from Anthropic: > 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. Most “agents” today fall into the workf…

Let me clarify: we are discussing how the Agent is internally implemented, given LLM calls and tools. It can be built using a graph, where one node makes decisions that branch out to tools and can loop back.

The workflow can vary. For example, it can involve multiple LLM calls chained together without branching or looping. It can also be built using a graph.

I know the terms "graph" and "workflow" can be a bit confusing. It’s like we have a low-level 'cache' at the CPU level and then a high-level 'cache' in software.

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#37

Post by jumploops »

zh2408 wrote: post #36
jumploops wrote: post #34

Anthropic[0] and Google[1] are both pushing for a clear definition of an “agent” vs. an “agentic workflow” tl;dr from Anthropic: > 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. Most “agents” today fall into the workf…

Let me clarify: we are discussing how the Agent is internally implemented, given LLM calls and tools. It can be built using a graph, where one node makes decisions that branch out to tools and can loop back. The workflow can vary. For example, it can involve multiple LLM calls chained together without branching or looping. It can also be built using a graph. I know the terms "graph" and "workflow" can be a bit confus…

Yes, the difference is that in the “pure” agent approach, the model is the only thing directing what to do.

In a sense there’s still a graph of execution, but the graph isn’t known until the “agent” runs and decides what tools to use, in what order, and for how long.

There is no scaffold, just LLM + MCP (or w/e) in a loop.

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#38

Post by jwpapi »

campbel wrote: post #7

I follow Mr. Huang, read/watch his content and also plan to use PocketFlow in some cases. A preamble, because I don't agree with this assessment. I think agents as nodes in a DAG workflow is _an_ implementation of an agentic system, but is not the systems I most often interact with (e.g. Cursor, Claude + MCP). Agentic systems can be simply the LLM + prompting + tools[1]. LLMs are more than capable (especially chain-o…

I have to agree this is a bit too simple for being anything of substance. That is not what really agentic means. This is basically implementing ChatGPT into Zapier.

When you work with agentic LLMs you should worry about prompt chaining, parallel execution, deciding points, loops and more of these complex decisions.

People who didn’t know what’s in first article shouldn’t use Pocketflow and go with N8N or even Zapier.

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#39

Post by zh2408 »

jumploops wrote: post #37
zh2408 wrote: post #36

Earlier quoted context omitted.

Let me clarify: we are discussing how the Agent is internally implemented, given LLM calls and tools. It can be built using a graph, where one node makes decisions that branch out to tools and can loop back. The workflow can vary. For example, it can involve multiple LLM calls chained together without branching or looping. It can also be built using a graph. I know the terms "graph" and "workflow" can be a bit confus…

Yes, the difference is that in the “pure” agent approach, the model is the only thing directing what to do. In a sense there’s still a graph of execution, but the graph isn’t known until the “agent” runs and decides what tools to use, in what order, and for how long. There is no scaffold, just LLM + MCP (or w/e) in a loop.

Yes!!

Re: LLM Agents Are Simply Graph – Tutorial for Dummies

#40

Post by throwaway7783 »

yed wrote: post #18
zh2408 wrote: post #17

Earlier quoted context omitted.

I think you’re referring to function calling: https://platform.openai.com/docs/guides/function-calling This still returns a string. You need to explicitly program the branch to the right function. For example, check out how OpenAI Agents, released a week ago, rely on a workflow: https://github.com/openai/openai-agents-python/blob/48ff99bb...

No I'm referring to the newest generation of agentic models one of which I linked to. These are not fully released but it is where the newest generation of research is headed.

Operator/Computer Use is a bridge until we no longer need any tools at all
Post reply on HN