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.

For an agent that runs for fifty turns, calls a dozen tools, and reads thousands of tokens of intermediate output, the wording of the original instruction is a small fraction of what the model sees. T

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

终端优先 —— 核心循环只有三个模块约 1000 行代码，无隐藏编排层" — Webwright extends traditional agent architecture by adopting a terminal-first, minimal-orchestration approach with only 3 core modules and ~1000 lines, eliminati

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

An Agent must first understand its current task environment. This includes: parsing the user's natural language input, reading external data sources (databases, APIs, documents), and retrieving contex

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

To speed things up and parallelize work, we built an always-running agent system" — Demonstrates scaling from manual sequential experiment execution to parallel distributed agent fleet running thousan

Frames memory/context as architectural requirements for multi-session agents, not optional features.

Query agent pattern described (takes natural language, understands data structure, constructs queries, evaluates results, reformulates) is agent behavior—reasoning loop with feedback.

Building a 'fully working AI Exam Builder' powered by Claude + MCP is agentic—Claude orchestrates decisions, delegates to tools, maintains reasoning thread.

building your own is quite simple and you'll be happy you did: any model you want (self-hosted if needed), fully customizable to your stack" — Hugging Face describes their Moon Bot implementation as a

Explains how agentic systems (Cursor, Claude Code) require standardized tool access layers. MCP is the infrastructure enabling autonomous agent action on external data.

React, Plan-and-Execute, smolagents are specific agent architectures analyzed; each implies different context structures

Understanding MCP vulnerability patterns is essential for designing safe agent-to-tool communication architectures. Shows why naive agent tool-calling can be dangerous.

2023+ evolution adds memory and tool use to agents; 2025 extends to multi-agent orchestration with shared context graphs

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