We started building Arti like many teams do \u2014 with the idea that we needed an orchestration layer<\/strong> for intelligent software.<\/p>\n But our background isn\u2019t in AI demos or LLM wrappers. It\u2019s in industrial software automation<\/strong> \u2014 manufacturing, automotive, and systems where software controls real-world processes, robots, and operations. In those environments, failure is not a UX issue. It\u2019s a breakdown with real consequences. And in that world, orchestrating behavior isn\u2019t enough. You need to manage state. Surface decisions. Control complexity. You need production-grade agent systems.<\/p>\n So we approached the agentic problem from first principles. At first, orchestration seemed like the answer. But it quickly became clear:<\/p>\n Orchestration alone doesn\u2019t scale. It creates a bottleneck at the control layer.<\/p>\n<\/blockquote>\n What we needed wasn\u2019t another framework. We needed a system architecture \u2014 one that could support a\u00a0Mixture of Experts<\/strong> approach<\/a> \u2014 not in the model sense, but in the system architecture<\/strong>:<\/p>\n Modular agents with clear responsibilities<\/p>\n<\/li>\n Context-aware routing<\/p>\n<\/li>\n Typed, testable state<\/p>\n<\/li>\n Prompt behaviors that could be versioned, composed, and evolved<\/p>\n<\/li>\n Collaboration between humans and AI, not top-down command loops<\/p>\n<\/li>\n<\/ul>\n We tested the available frameworks:<\/p>\n These weren\u2019t frameworks<\/a>. They were demo wrappers<\/strong>. None of them survived contact with real-world complexity.<\/p>\n So we began defining a different approach \u2014 what we now call Cognitive Agentic Architecture: a modular, typed, observable, human-compatible architecture for intelligent systems.<\/p>\n And then we found two teams thinking like we were:<\/p>\n Anthropic<\/strong>, emphasizing pattern clarity and composable simplicity<\/p>\n<\/li>\n PydanticAI<\/strong>, advocating minimal, type-safe, system-aware agent design<\/p>\n<\/li>\n<\/ul>\n Neither of them builds \u201cframeworks\u201d either. In this post, we\u2019ll walk through what we respect in both \u2014 and how Arti expands those principles into something deployable, introspectable, and durable.<\/strong><\/p>\n Because agentic systems aren\u2019t just workflows. This post is about what Anthropic<\/a> and PydanticAI<\/a> get right\u2014 and what\u2019s needed to go further.<\/p>\n<\/div><\/div><\/div><\/div><\/div> Anthropic\u2019s guide to building effective agents is one of the most practical and insightful resources in the agent framework space.<\/p>\n Their core advice? And they\u2019re right. For many use cases, that\u2019s enough.<\/p>\n But here\u2019s where things break down:<\/p>\n There\u2019s no structured approach to long-term state<\/strong>.<\/p>\n<\/li>\n Tool calls are prompt-engineered, not typed<\/strong> or contracted<\/strong>.<\/p>\n<\/li>\n There\u2019s no model for semantic memory<\/strong> or reusable prompt modules.<\/p>\n<\/li>\n The execution environment lacks runtime introspection<\/strong>, rollback, or monitoring.<\/p>\n<\/li>\n Their approach assumes the LLM is the agent<\/strong> \u2014 when in reality, it should be just one part of a modular system.<\/p>\n<\/li>\n<\/ul>\n In short: great software starts with patterns, but it scales with architecture.<\/p>\n<\/div><\/div><\/div><\/div><\/div> PydanticAI takes a unique approach that we deeply respect.<\/p>\n Where Anthropic is pattern-first, Pydantic is software-first<\/strong>:<\/p>\n Typed tools and agent inputs<\/p>\n<\/li>\n Explicit delegation and agent handoffs<\/p>\n<\/li>\n Avoidance of DAG fetishism<\/p>\n<\/li>\n Code that\u2019s readable, testable, inspectable<\/p>\n<\/li>\n<\/ul>\n Their best metaphor?<\/p>\n \u201cDon\u2019t use a nail gun unless you need one.\u201d<\/em><\/p>\n<\/blockquote>\n That could be Arti\u2019s motto.<\/p>\n But there are gaps here too:<\/p>\n There\u2019s no concept of semantic context or ontologies<\/strong> \u2014 state is structured, but not meaningfully enriched.<\/p>\n<\/li>\n There\u2019s no built-in notion of collaborative interaction<\/strong> \u2014 everything is still \u201cagent does X.\u201d<\/p>\n<\/li>\n There\u2019s minimal treatment of execution observability<\/strong> or runtime introspection.<\/p>\n<\/li>\n Prompt handling is typed, but not versioned, overloaded, or runtime-dispatched<\/strong>.<\/p>\n<\/li>\n<\/ul>\n PydanticAI is the best foundation we\u2019ve seen for agent logic as code<\/strong> \u2014 but not yet for agentic systems at scale.<\/strong><\/p>\n<\/div><\/div><\/div><\/div><\/div> We didn\u2019t start in chatbots or demos. We built automation software for manufacturing, automotive, and industrial systems<\/strong>.<\/p>\n In our world:<\/p>\n State isn\u2019t ephemeral \u2014 it drives machines.<\/p>\n<\/li>\n Errors aren\u2019t recoverable with retries \u2014 they cost real money.<\/p>\n<\/li>\n You don\u2019t ship a product that sometimes works.<\/p>\n<\/li>\n<\/ul>\n So when we look at agents, we don\u2019t see magic. We see a control system that needs:<\/p>\n Versioned, modular behavior<\/p>\n<\/li>\n Semantic context and state inspection<\/p>\n<\/li>\n Real-time observability and rollback<\/p>\n<\/li>\n Collaborative control models between human and AI<\/p>\n<\/li>\n<\/ul>\n We respect Anthropic\u2019s clarity. We align with PydanticAI\u2019s posture. But we build like systems engineers<\/strong>, not AI whisperers.<\/p>\n<\/div><\/div><\/div><\/div><\/div> Arti builds on the strengths of Anthropic and PydanticAI, extending their principles into a production-grade solution that meets the demands of real-world applications.<\/p>\n<\/div>\n We\u2019re not building a framework. We\u2019re building an execution layer<\/strong> for intelligent, stateful, observable, modular software \u2014 where LLMs are a component, not a controller.<\/p>\n<\/div><\/div><\/div><\/div><\/div> We agree with Anthropic:<\/p>\n \u201cAdd complexity only when it demonstrably improves outcomes.\u201d<\/p>\n<\/blockquote>\n And we agree with PydanticAI:<\/p>\n \u201cDon\u2019t use more power than you can control.\u201d<\/p>\n<\/blockquote>\n But eventually, even the cleanest pattern or best-typed agent will hit a wall \u2014 because agents aren\u2019t demos anymore. They\u2019re infrastructure.<\/p>\n Arti is what happens when you treat agents like real systems. Join us as we redefine the future of agentic architecture and build the foundation for the next generation of intelligent systems.<\/strong><\/p>\n<\/div><\/div><\/div><\/div><\/div> Netflix built a foundation model for recommendation systems. We\u2019re building one for cognition. What they\u2019ve done shows us where agentic architecture is headed \u2014 and why DAGs, SDKs, and chat loops won\u2019t get us there. In the next post, we will examine how Netflix\u2019s approach aligns with ours and what it teaches us about agentic infrastructure.<\/p>\n<\/div><\/div><\/div><\/div><\/div><\/p>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":4404,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"content-type":"","footnotes":""},"categories":[249],"tags":[347,348,345,346,336],"class_list":["post-11033","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-implementation-and-best-practices","tag-agent-system-design","tag-agentic-systems","tag-ai-agent-frameworks","tag-ai-agents-frameworks","tag-ai-in-industry"],"_links":{"self":[{"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/posts\/11033","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/comments?post=11033"}],"version-history":[{"count":2,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/posts\/11033\/revisions"}],"predecessor-version":[{"id":11142,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/posts\/11033\/revisions\/11142"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/media\/4404"}],"wp:attachment":[{"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/media?parent=11033"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/categories?post=11033"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.artiquare.com\/de\/wp-json\/wp\/v2\/tags?post=11033"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\n
\n
\n
They\u2019re building philosophies<\/strong> that map to real-world complexity without abstraction debt.<\/p>\n
They\u2019re software.
And we build software like it matters.<\/p>\nAnthropic: Patterns Over Frameworks<\/h2><\/div>
Start simple.
Don\u2019t build agents unless you need them.
Compose small, testable workflows using prompt chaining, routing, and tool calls.
Use the LLM as a decision engine, not a black box.<\/p>\n\u26a0\ufe0f The Limits of Pattern-Only Thinking:<\/h4>\n
\n
PydanticAI: Typed, Explicit, Composable Agents<\/h2><\/div>
\n
\n
\u2757 The Missing Layers:<\/h4>\n
\n
Where We Come From \u2014 and Why This Matters<\/h2><\/div>
\n
\n
What Arti Adds \u2014 Without Breaking the Philosophy<\/h2><\/div>
\n\n
\n \nPrinciple<\/th>\n Anthropic<\/th>\n PydanticAI<\/th>\n Arti (CAA-based)<\/th>\n<\/tr>\n<\/thead>\n \n Simplicity first<\/td>\n \u2705<\/td>\n \u2705<\/td>\n \u2705 but modularized<\/td>\n<\/tr>\n \n Typed tools<\/td>\n \u274c<\/td>\n \u2705<\/td>\n \u2705 (enforced + testable)<\/td>\n<\/tr>\n \n Prompt modularity<\/td>\n \u26a0\ufe0f (manual)<\/td>\n \u2705<\/td>\n \u2705 (versioned + runtime dispatched)<\/td>\n<\/tr>\n \n Execution state<\/td>\n \u26a0\ufe0f (LLM memory)<\/td>\n \u2705<\/td>\n \u2705 (typed + semantic)<\/td>\n<\/tr>\n \n Human-AI loops<\/td>\n \u26a0\ufe0f<\/td>\n \u274c<\/td>\n \u2705 (interrupts, approvals, collaboration)<\/td>\n<\/tr>\n \n Observability<\/td>\n \u26a0\ufe0f<\/td>\n \u26a0\ufe0f<\/td>\n \u2705 (first-class, not afterthought)<\/td>\n<\/tr>\n \n Rollback \/ Eval<\/td>\n \u274c<\/td>\n \u274c<\/td>\n \u2705 (built-in evaluation + time travel)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n Closing: Patterns Are a Start. Systems Must Follow.<\/h2><\/div>
\n
\n
Next up:<\/h2><\/div>