agent architecture

Agent with tool-use loop is explicitly discussed as alternative to RAG

This article examines how AI agents work, their current capabilities, and the infrastructure needed for reliable function" — Article provides direct technical analysis of how AI agents function and th

The core insight is a clean separation of concerns into three distinct layers, each with a different owner, lifecycle, and trust level. The power of this separation is that each layer evolves independ

An AI agent is a system built around a large language model (LLM) that can reason about tasks, use tools, maintain memory across interactions, and make decisions about how to proceed without following

[direct] "AI agent architecture is the structural framework that defines how an AI system gathers information, processes data, makes decisions, and executes tasks." — Provides foundational definition

MCP is the infrastructure layer that enables autonomous agents to act on the external world. Without it, agents are confined to reasoning-only mode.

an agent as a system using an LLM to decide the control flow of an application" — Article directly defines and structures LangChain agents as LLM-driven control flow systems, core architecture pattern

four key components are required: an agent core, a memory module, agent tools, and a planning module" — Article explicitly defines the foundational architectural components of LLM agent systems

LLM → agent → agent harness → coding harness" — Article explicitly describes the architectural layers of a coding agent, showing how components stack from LLM through harnesses.

The next generation of these tools is agent-based, operating with more autonomy and potentially without human oversight." — Article addresses the architectural shift toward autonomous AI agents and id

Chronicle 在本地运行沙盒化的后台智能体，持续捕获屏幕图像并生成记忆" — Chronicle exemplifies a sandboxed background agent architecture that continuously observes environment state (screen images) and synthesizes understanding (me

Isolating context - splitting it up to help an agent perform a task." — Introduces context isolation as an architectural pattern for agent design, adding a new dimension to how agents structure their

先让 Agent 完成几项真实任务（真实场景比合成测试更能暴露问题）。在LangFuse中打开对应trace，重点关注："where it gets confused"" — Article provides concrete debugging methodology: running real tasks and analyzing where agent reasoning fails, d

MCP reduces the integration tax that makes multi-system automation fragile. Without MCP, connecting multiple agents to multiple systems creates a web of custom integrations." — Article articulates how

A well-designed agent can apply qualitative judgments, not just follow instructions." — Evidences that effective agent architectures require sophisticated reasoning capabilities beyond simple instruct

Our create_agent primitive in LangChain exposes the one of the simplest Harnesses for builders to extend, a ReAct loop with support for tools, middleware (hooks), and model choice. It's a great place

AI agents differ from traditional chatbots in one key way. They perform tasks, not just conversations." — Article identifies task execution as the defining architectural difference for AI agents, supp

Proposes specific architectural pattern (autonomous compression vs. fixed-threshold) for agent decision-making

Agent --> Reasoning, Agent --> Tool Selection, Action Execution, Result Analysis" — Repository demonstrates complete agent architecture with reasoning, tool selection, action execution, and result ana

Claude Code to automatically switch from preloading MCP tools to search-based loading" — Exemplifies adaptive agent architecture where tool loading strategy adjusts dynamically based on context, showi

Build complete ReAct and MDP agent loops with real tool execution" — Covers both ReAct (Reasoning-Acting) and Markov Decision Process agent loops with practical tool execution implementation

Introducing our new research direction on Recursive Language Models. We are sharing our initial experiments showing the promise of RLMs." — RLMs represent a specific architectural innovation for agent

agentic support is new baseline for any SaaS" — Article asserts that agentic capabilities have become essential architectural requirement for SaaS platforms

Article explicitly contrasts Claude Code's agent-system design (better context chaining) against IDE extensions and CLI tools, showing agent architecture as superior for context preservation.

A decade of information retrieval and three years of agent harness engineering, poured into a local-first knowledge system" — napkin represents evolved thinking on agent harness engineering with novel

Agentic AI creates goal-driven autonomous agents that can observe their environment, plan actions, execute tasks, and maintain long-term memory. Unlike standard LLMs, which only respond to prompts, ag

Plugins explicitly support extending agents (skills/ and agents/ subdirectories). The architecture allows composing subagents and skills into reusable units that extend the main agent's capabilities.

Discussion of 'fully unprompted agents' and 'agent architectures' implies context as foundation of agent behavior

state machines — nodes as decisions, edges as transitions, loops as retries, supervisors as orchestration" — LangGraph demonstrates a concrete architectural pattern for building agents: state machines

[direct] "LangGraph creates cyclical workflows where agents can think, act, observe, and decide their next steps dynamically." — Article demonstrates LangGraph as a concrete implementation of cyclical

常驻在 CLI 里，运行于 Unix 之上；能执行 grep / awk / sed / cron，能管道、能派生子任务" — Describes architectural composition: agents as Unix-native processes with subprocess orchestration and piping capabilities.

CodeAct is a specific instantiation of the broader principle that action-space design (what agents can *do*) is foundational to context management.

Imagine an AI that doesn't just generate text but actively uses tools to solve real-world problems. That's the power of Agentic AI, and LangChain and LangGraph are the keys." — Article explicitly defi

architecture, steps, patterns, and best practices" — The article provides architectural guidance and patterns for agent design, covering the systematic structure of how agents are built and function.

MCP code execution is an architectural choice that affects how agents scale. Validates the importance of architecture in context efficiency.

A complete enterprise agent stack in 2026 will use all four protocols: MCP for tool access, A2A for agent coordination, and ACP or UCP for commerce transactions depending on the environment. The four

build production-ready AI agents" — Article demonstrates practical implementation patterns from Anthropic and LangChain for production agent systems

years of experience in building AI systems is that Contexts are underrated. It is clearly affecting the way your RAG or AI Agents perform." — Article provides evidence-based insight that agent perform

Build your first agent with models, tools, memory, and streaming" — Tutorial explicitly demonstrates building agents as a core learning objective, showing models, tools, and memory integration.

Using the Bun runtime—known for its extreme speed in executing JavaScript—Claude Code monitors specific plugins (currently Telegram and Discord)." — Claude Code Channels demonstrates a concrete agent

standardized way for an LLM to access tools via a client-server architecture" — MCP introduces a client-server architectural pattern for how agents should be structured to access tools, extending agen

Here's where LangGraph shines—we'll build a workflow that can adapt based on results" — Article provides practical example of LangGraph's agent graph construction for adaptive workflows

Identifies that agents require three types of context data carefully assembled. This is agent-specific context engineering pattern, not generic retrieval.

CrewAI brings modularity and collaboration to LLM agents. Whether you're automating content pipelines or creating intelligent assistants, CrewAI gives you a clean abstraction for multirole task orches

Specifically designed for 'agent and domain-specific reasoning'; provides architectural pattern for agentic systems

Before MCP, every AI agent needed unique, hand-coded integration logic for every external service it accessed. This created an unsustainable development burden and vendor lock-in. MCP solves this by e

Tool is built for observing agent systems with tool calling, thinking, and delegated background jobs. Reveals that production agents need observability infrastructure as a first-class concern.

today agents are good at "OLTP" tasks RLMs make them good at "OLAP" tasks as well" — Article extends understanding of agent capabilities by introducing OLAP vs OLTP distinction, showing how RLMs expan

Local LLM + MCP server is foundational agent pattern; article demonstrates simple agent setup

Demonstrates agent-server interaction pattern: agent requests tools → LLM selects → server executes → results returned to LLM. This is core multi-agent orchestration.