DAGWorks Inc.

Happy New Year! Here's a recap of the last month and some of 2024. Thanks to the community and our contributors this year. #Hamilton + #Burr 2024 stats: > 35M+ telemetry events (10x growth), > 100K+ unique IPs (10x growth) from 1000+ companies, > 1M+ total downloads. #Hamilton December release highlights: > TypedDict support, Snowflake example #Burr December release highlights: > Anyscale's Ray executor for parallelism > Persistence, i.e. fault tolerance, for parallelism Blogs: > We have four this past month! They cover Hamilton internals, parallelism, and TDD LLM application development! Links in the newsletter! In the wild: > Burr called out by AI Agent Ops Alliance™ (AOA) > Jernej Frank's recording on the internals of Hamilton decorators > how to deploy the Hamilton UI on Snowflake

🍾 Happy new year! 🍾 We wrote a fun post on building parallel agents with #burr and #ray to get the year started. https://lnkd.in/grbTQnqv The hard problems at the center of it. How do you handle parallel tasks in your agent's workflow? What if the orchestrator dies/loses connection? What if the tasks are flaky? Burr provides a host of tools to solve these without much additional effort -- most of this just *works* out of the box. The idea is that spawned sub-applications inherit their parent's persistence capabilities, enabling you to restart any failed applications where you left off, and restart the entire suite of applications from their prior state if the parent dies, affording you an eventually completing workflow! We use: 🥶 #Burr to orchestrate/persist ☀️ #Ray by Anyscale to distribute out execution 💽 Any db you want to persist data between runs The distribution engine and database we use are pluggable -- while the Burr library provides a few plugins, you can (and should!) easily write your own.

👉 The choice of Agent Ops tooling depends on the specific use case needs and preferences. 🚀 For state machine modeling & implementation: --------- 1️⃣ If precise control over state and detailed visualization, DAGWorks Inc. Burr might be the best choice. 2️⃣ If you prefer a higher-level abstraction and seamless integration with LangChain, LangGraph could be a good fit. 3️⃣ And if you need a more versatile tool for various NLP tasks, including agent development, Haystack might be the way to go. -------- 🛠️ Burr: 🔹Explicit State Machine Focus: Burr is built with state machines as the core concept. You define "actions" as Python functions that explicitly read from and write to a central state object.  🔹Fine-grained Control: Burr gives you very granular control over state transitions and actions, allowing for complex logic and conditional branching. 🔹Visualization: Burr's telemetry UI provides a clear visual representation of the state machine, making it easy to understand and debug agent behavior. ---- 🛠️ LangGraph: 🔹Graph-based Representation: LangGraph uses a graph structure to define the state machine, where nodes represent actions or tools, and edges represent transitions.  🔹Higher-level Abstraction: LangGraph provides a higher level of abstraction compared to Burr, focusing on the flow of actions and data between different components. 🔹Integration with LangChain: LangGraph is tightly integrated with LangChain, making it easy to incorporate various LLM chains and tools into your agent workflow. ---- 🛠️ Haystack: 🔹Pipelines with State Machine Elements: Haystack's Pipelines feature incorporates some state machine concepts, allowing for conditional routing and branching within a workflow.  🔹Less Explicit Focus: However, Haystack doesn't explicitly enforce a state machine structure for all applications. It's more flexible and can be used for a wider range of NLP tasks beyond agent development. 🔹Limited Visualization: Haystack doesn't have a dedicated UI for visualizing state machines like Burr. -------- ✨ Agentic Systems are the future of AI - AI Agent Ops Framework™ (AOF) Unlocks the Potential 🌈 Join the industries' only dedicated AI Agent Ops Community: https://lnkd.in/dMDFZMJa

I'm really excited about some new capabilities we launched in #Burr! You can now easily run parallel, multi-agent workflows with a set of abstractions that enables a simple map/reduce pattern -- E.G. generating multiple candidates to evaluate, running a variety of simultaneous tools, scraping multiple web-pages, etc... We wrote about it here -- I'm happy with how Burr has grown to enable more and more powerful agentic systems:

Really excited for this guest blog post by Jernej Frank. This is something new -- he's one of the #OS contributors that dove deepest into #Hamilton, and has had a massive impact on some of the core aspects including graph execution and lifecycle adapters. In this post, he digs into an abstraction that we designed to make building ergonomic DAGs easier -- how Hamilton leverages python decorators to enable modular, readable, and extensible data transforms. Worth a read -- there's a bit for everyone! He goes over the basics of Hamilton, the trade-off between explicit/verbose code, how hamilton leverages decorators to mitigate that trade-off, and the architecture details of how that works. On a personal note -- I've also really enjoyed working with Jernej Frank as he dove into the deep end of Hamilton's implementation. Goes to show how #opensource can build and a community and bring a ton of folks along for the ride! https://lnkd.in/gZfZXCs8

Tired of the deployment headaches with #LLM agents? BentoML takes care of the heavy lifting - from REST endpoints to scaling. Great post showing how to combine #Burr and #BentoML for streamlined agent deployment. Read the blog post to learn more: https://lnkd.in/gJNccqw9

Excited to see #burr / DAGWorks Inc. mentioned here!

Really excited to talk about building out #AIAgents reliably with #Burr at PyData Global next week! https://lnkd.in/gafKvBM9 If you haven't already, make sure to register -- great roster of speakers!

A #Burr user shared this video https://lnkd.in/gie9N6TG with me on the "problem with frameworks". Worth a watch. I 💯% agree with the take home. The "coupling problem" is the reason why people graduate out of frameworks like LangChain & LlamaIndex. You become overly coupled and then find yourself overtime asking why am I using this? It's not that the framework authors did this maliciously, it's just that they optimized for their needs, in this case for POCs, which is not the same as long lived maintainable code. That's why we see people either build their own frameworks, or they hopefully discover #hamilton & #burr and realize that there are frameworks that allow "loose coupling" that don't get in your way (as a platform person and framework author we optimize for maintainable code - and the user who shared the video agrees and is why they use Burr). A good example of this is FastAPI - very easy to not couple your business logic and iterate quickly no matter the age of the code. So how can you tell where a framework lies on the spectrum of tight coupling versus not? Some tests: (1) How many "objects" do I need to use from the framework to couple the logic I want to happen? The fewer the better. E.g. with #hamilton by default it's 0. With #burr it's just 1 and that's due to state for edge transitions, but that's easy to decouple from. (2) How many framework imports do you need to get something to run? The less the better - consider #burr vs LangChain using #langgraph (see image). If you're feeling framework pains, or are curious on how it can be done right, checkout the links in the comments, or comment yourself/tag someone who you think would like this post. #python #opensource #genai #llmops

Happy Friday! Here's what happened: > #Hamilton release highlights: User contributed async support for @pipe (thanks Jernej Frank!) + various small fixes > #Burr release highlights: 🤖 || . Parallelism V1 is out! This is 🚀. It's a highly asked for construct. You could do it before, but now it's simpler to do! Excited for people to build more parallel actions / sub-agents! More in the newsletter. > Office Hours & Meet ups for Hamilton & Burr. Sign up, come and ask questions. We'd love to see you there. Details in the newsletter. > Free Lightning lesson on #GenAI from first principles for SWEs, DS, and MLEs with Hugo Bowne-Anderson on Maven on Tuesday - sign up! Link in the newsletter. > Blog post: Flashcard generator with #Instructor + #Burr. This is a fun post showing what you can do with GenAI and easily and quickly with Instructor & Burr! > In the wild: a few mentions on LinkedIn for both Hamilton & Burr Thanks to Eric Brichetto, Dr. Milan Jelisavčić, & Unwind AI for the shoutouts!