Paper deep dive
STEM Agent: A Self-Adapting, Tool-Enabled, Extensible Architecture for Multi-Protocol AI Agent Systems
Alfred Shen, Aaron Shen
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%
Last extracted: 3/26/2026, 1:32:20 AM
Summary
STEM Agent is a modular, multi-protocol AI agent architecture inspired by biological pluripotency. It features an undifferentiated agent core that differentiates into specialized protocol handlers (A2A, AG-UI, A2UI, UCP, AP2), tool bindings via the Model Context Protocol (MCP), and a multi-type memory system. The framework includes a Caller Profiler for continuous behavioral adaptation and a biologically-inspired skills acquisition system where recurring interaction patterns crystallize into reusable skills.
Entities (6)
Relation Signals (3)
STEM Agent → implements → A2A
confidence 100% · The framework unifies five interoperability protocols (A2A, AG-UI, A2UI, UCP, and AP2)
STEM Agent → uses → Model Context Protocol
confidence 100% · externalizes all domain capabilities through the Model Context Protocol (MCP)
Caller Profiler → adapts → STEM Agent
confidence 90% · enabling per-user behavioral adaptation without manual configuration
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Current AI agent frameworks commit early to a single interaction protocol, a fixed tool integration strategy, and static user models, limiting their deployment across diverse interaction paradigms. To address these constraints, we introduce STEM Agent (Self-adapting, Tool-enabled, Extensible, Multi-agent), a modular architecture inspired by biological pluripotency in which an undifferentiated agent core differentiates into specialized protocol handlers, tool bindings, and memory subsystems that compose into a fully functioning AI system. The framework unifies five interoperability protocols (A2A, AG-UI, A2UI, UCP, and AP2) behind a single gateway, introduces a Caller Profiler that continuously learns user preferences across more than twenty behavioral dimensions, externalizes all domain capabilities through the Model Context Protocol (MCP), and implements a biologically inspired skills acquisition system in which recurring interaction patterns crystallize into reusable agent skills through a maturation lifecycle analogous to cell differentiation. Complementing these capabilities, the memory system incorporates consolidation mechanisms, including episodic pruning, semantic deduplication, and pattern extraction, designed for sub-linear growth under sustained interaction. A comprehensive 413-test suite validates protocol handler behavior and component integration across all five architectural layers, completing in under three seconds.
Tags
Links
- Source: https://arxiv.org/abs/2603.22359v1
- Canonical: https://arxiv.org/abs/2603.22359v1
Trouble viewing inline? Open PDF directly →
Full Text
32,695 characters extracted from source content.
Expand or collapse full text
STEM Agent: A Self-Adapting, Tool-Enabled, Extensible Architecture for Multi-Protocol AI Agent Systems Alfred Shen Aaron Shen Abstract Current AI agent frameworks commit early to a single interaction protocol, a fixed tool integra- tion strategy, and static user models, limiting their deployment across diverse interaction paradigms. We introduce STEM Agent (Self-adapting, Tool- enabled, Extensible, Multi-agent), a modular ar- chitecture inspired by biological pluripotency: an undifferentiated agent core that differentiates into specialized protocol handlers, tool bindings, and memory subsystems, composing into a function- ing AI system. The framework unifies five interop- erability protocols (A2A, AG-UI, A2UI, UCP, and AP2) behind a single gateway, introduces a Caller Profiler that continuously learns user preferences across 20+ behavioral dimensions, externalizes all domain capabilities through the Model Context Protocol (MCP), and implements a biologically- inspired skills acquisition system where recurring interaction patterns crystallize into reusable agent skills through a maturation lifecycle analogous to cell differentiation. The memory system in- corporates consolidation mechanisms (episodic pruning, semantic deduplication, and pattern ex- traction) designed for sub-linear growth under sustained interaction. A 413-test suite validates protocol handler behavior and component integra- tion across all five architectural layers, completing in under 3 s. 1. Introduction In developmental biology, a stem cell is remarkable for its pluripotency: it is undifferentiated yet capable of special- izing into any cell type, which then compose into organs that sustain a living body. We take this as a design principle for AI agent systems. The STEM Agent (Self-adapting, Tool-enabled, Extensible, Multi-agent) is an undifferenti- ated agent core that differentiates into specialized protocol . Correspondence to: Alfred Shen<alfreshe@amazon.com>, Aaron Shen<aaron.shen@berkeley.edu>. Preprint. March 25, 2026. handlers, tool bindings, and memory types, which compose into a functioning system that supports diverse business workflows. This analogy is not merely rhetorical. Current agent frame- works exhibit what we term architectural lock-in: they com- mit early to a single interaction protocol (e.g., REST-only or chat-only), a fixed tool integration strategy, and static user models. The result is an ecosystem of rigid, single-purpose agents that cannot interoperate, adapt, or compose (Ferrag et al., 2025; Tran et al., 2025). Meanwhile, the proliferation of agent communication protocols—MCP (Ehtesham et al., 2025), A2A (Habler et al., 2025), and emerging standards for UI streaming and commerce—demands architectures that are protocol-pluralistic by design (Li & Xie, 2025). STEM Agent addresses these gaps with the following con- tributions: 1.Multi-protocol interoperability. To our knowledge, the first agent framework implementing five inter- operability protocols—A2A (agent-to-agent), AG-UI (streaming UI events), A2UI (dynamic UI composi- tion), UCP (universal commerce), and AP2 (agent payments)—behind a unified gateway. Of these, A2A and AG-UI follow published external specifications; UCP and AP2 are novel protocols proposed herein. 2.Caller Profiler. A multi-dimensional user model- ing system that continuously learns caller preferences across 4 categories and 20+ dimensions using expo- nential moving averages, enabling per-user behavioral adaptation without manual configuration. 3. MCP-native tool integration. All external domain capabilities are acquired at runtime via the Model Con- text Protocol, separating agent reasoning from domain knowledge. Meta-reasoning rules (strategy selection, parameter tuning) remain in code. 4.Self-tunable behavior parameters. Ten continuously adjusted parameters (reasoning depth, creativity, ver- bosity, etc.) that adapt to task characteristics and caller profiles. 5.Commerce-ready agent protocols. Novel UCP and AP2 protocol handlers enabling checkout sessions, 1 arXiv:2603.22359v1 [cs.AI] 22 Mar 2026 STEM Agent mandate-based payments, and audit trails within the agent interaction loop. 6.Biologically-inspired skills acquisition.A cell- differentiation model where recurring interaction pat- terns crystallize into reusable skills that mature through activation (progenitor→committed→mature) or un- dergo apoptosis on persistent failure, complemented by manual skill plugin support. 2. Related Work Multi-agent frameworks. The rapid growth of LLM- based agent systems has produced a diverse ecosystem of frameworks, each optimizing for different coordination pat- terns. Tran et al. (2025) survey these mechanisms—role- assignment, debate, and orchestration—across AutoGen, MetaGPT, CAMEL, and CrewAI. A recurring finding is that most frameworks commit to a single communication protocol and lack per-user adaptation. Orogat et al. (2026) confirm this in MAFBench, a unified benchmark showing that architectural choices drive 100×latency differences and 30% accuracy gaps across frameworks. Dang et al. (2025) address coordination rigidity through evolving orchestra- tion, while Drammeh (2025) demonstrate that multi-agent LLM orchestration can achieve deterministic decision sup- port for incident response. STEM Agent builds on this line of work by unifying five protocols behind a single gateway and adding continuous caller modeling. Agent communication protocols. The interoperability landscape is fragmented across competing standards. Eht- esham et al. (2025) survey four major protocols—MCP, ACP, A2A, and ANP—concluding that MCP and A2A are complementary (vertical tool access vs. horizontal agent communication) rather than competing. Li & Xie (2025) critically analyze integration challenges when combining A2A and MCP, identifying schema translation and lifecy- cle management as key pain points. Jeong (2025) study the MCP×A2A framework. Security is an active concern: Habler et al. (2025) analyze A2A threat models, while An- biaee et al. (2026) provide a comparative security analysis across MCP, A2A, Agora, and ANP. Sarkar & Sarkar (2025) map classical design patterns (Mediator, Observer) to MCP communication. The Agent Network Protocol (Chang et al., 2025) addresses decentralized discovery. Despite this pro- liferation, prior work implements at most two protocols; STEM Agent implements five, including two novel com- merce protocols. Agentic reasoning and adaptive compute. Wei et al. (2026) provide a comprehensive survey of agentic reason- ing, covering chain-of-thought, ReAct, reflexion, tree-of- thought, and debate paradigms. Alomrani et al. (2025) sur- vey adaptive test-time compute, showing that dynamically Table 1. Five-layer architecture overview. LayerComponentKey Counts 1Caller / User Layer4 adapters 2Standard Interface (Gateway)5 protocols 3Agent Core5 engines 3.5Security Layer4 IAM plugins 4Memory System4 memory types 5MCP Integration3 transports adjusting reasoning depth yields efficiency gains without quality loss. Li et al. (2025) propose budget-guided steering for LLM thinking. STEM Agent integrates four reasoning strategies with automatic selection based on task character- istics, drawing on these adaptive compute principles. MCP tools and benchmarks. Luo et al. (2025) bench- mark LLMs across 11 real-world MCP servers where even state-of-the-art models score below 44%; Fan et al. (2025) scale this to 4,000+ servers. Lumer et al. (2025) propose dynamic tool synchronization, and Hasan et al. (2026) find that 97.1% of MCP tool descriptions contain quality issues. Jayanti & Han (2026) and Schlapbach (2026) extend MCP with context-aware collaboration and schema-guided dia- logue convergence, respectively. Agent memory and self-adaptation.Ferrag et al. (2025) review the progression from LLM reasoning to autonomous AI agents, identifying continuous adaptation as a key open challenge. Ai et al. (2025) benchmark memory and con- tinual learning in LLM systems. Gallego (2026) propose distilling feedback into memory-as-a-tool, treating mem- ory as an explicit, learnable capability. Yadav et al. (2026) present a hierarchical multi-agent framework with hybrid memory. STEM Agent operationalizes these ideas through a four-type memory system and a Caller Profiler with self- tunable behavior parameters. 3. Architecture STEM Agent is organized into five layers, each correspond- ing to a distinct concern (Table 1). Figure 1 provides a visual overview. Following the stem cell analogy: Layer 3 (Agent Core) is the undifferentiated core that differentiates through Layer 2 (protocol handlers) and Layer 5 (tool bindings) into specialized capabilities, while Layer 4 (Memory) provides persistent state that guides future adaptation. 3.1. Cognitive Pipeline The Agent Core processes each request through an eight- phase cognitive pipeline (Algorithm 1). The PERCEIVE phase classifies intent into 10 categories, estimates complexity as one of three levels (simple, medium, 2 STEM Agent STEM Agent Self-adapting, Tool-enabled, Extensible, Multi-agent System · 6 Packages · TypeScript Monorepo · ~12 000 LOC CALLERS (caller-layer) CLI (REPL)StemAgentClient SDKA2A ClientAgent Mesh CollaborationFramework Adapters: AutoGen · CrewAI · LangGraph · OpenAI HTTP / WS / A2A / AG-UIAgentResponse STANDARD INTERFACE (standard-interface) Gateway Express · request-id · logging · rate-limit · error-handler REST /api/v1/* tasks · chat · profile WebSocket /ws rooms · streaming A2A /a2a (JSON-RPC) agent-card · push-notify SSE /chat/stream streaming responses Auth Middleware API Key · JWT · OAuth2 Swagger UI /docs · /api-docs AG-UI /ag-ui (SSE) typed event streaming A2UI /a2ui/* (Dynamic UI) 18 primitives · render · action UCP /ucp/* (Commerce) discovery · checkout · idempotency AP2 /ap2/* (Payments) mandates · receipts · audit trail AgentMessageAgentResponse AGENT CORE (agent-core) — StemAgent : IStemAgent Perceive → Adapt → Skill Match → Reason → Plan → Execute → Learn (async) 1 Perception Engine Intent classification (8 types) Complexity + urgency scoring Entity extraction (URL, code...) Memory-enriched context Caller style signals 2 Reasoning Engine StrategySelector (auto-pick) Chain-of-Thought ReAct (tool loop) Reflexion · Internal Debate Evidence + confidence 3 Planning Engine Procedural memory lookup LLM plan generation Dependency graph Parallel group computation Re-planning on failure 4 Execution Engine Parallel step execution tool_call · memory_lookup reasoning · response Retry (2x) + circuit breaker Step timeout (30s) re-plan on failure Adapt (BehaviorParams) depth · verbosity · creativity · confidence LLM Client Anthropic · Bedrock · NoOp Skill Manager crystallize · match · mature · apoptosis Cost Guardrail per-call · interaction · daily · monthly Tiered Model Selection Haiku (percept) · Sonnet · Opus (reason) Learn (async): store episode · update caller profile · record procedure · crystallize skills · skill maturation remember / learnrecall / searchcallToolMCPToolResult MEMORY & LEARNING (memory-system) Episodic Interaction history Vector similarity Importance scoring Semantic Knowledge triples Confidence + version Embedding search Procedural Learned procedures Success rate tracking Tags + preconditions User Context Caller profiles Session state Philosophy · Style MemoryManager (facade) remember · recall · learn · forget Indexer Prune · Dedup Embedding OpenAI · NoOp MCP INTEGRATION (mcp-integration) MCPManager — connectAll · discoverCapabilities · callTool · healthCheck Database SQL adapter PostgreSQL · MySQL API REST / GraphQL Retry + backoff File read · write list · search Tool CLI wrappers Custom exec Custom User-defined MCP servers StdioTransport (local processes)SSETransport (remote servers) INFRASTRUCTURE & EXTERNAL SERVICES PostgreSQL 17 + pgvector Relational + vector store Shared with stem-platform Redis 7 Session cache :6379 Anthropic LLM (Claude) Bedrock or direct API Haiku · Sonnet · Opus OpenAI Embeddings text-embedding-3-small 1536 dimensions External MCP Servers stdio / SSE transport Dynamic connect FOUNDATIONS (shared) Types & Schemas (Zod) AgentMessage · PerceptionResult · ExecutionPlan · Episode · Skill · MCPTool · AgentCard · AG-UI · A2UI · UCP · AP2 Utilities Pino logger · Error hierarchy (BaseError, ValidationError...) · IStemAgent · IMemoryManager · IMCPManager DEPLOYMENT — Docker Compose (3 svc + pgAdmin dev) · Dockerfile · .env config pgvector/pgvector:pg17 · redis:7-alpine · cost guardrails · tiered LLM models TESTING — Vitest · 37 test files · 413 tests · 100% pass · TypeScript strict Orchestrator · Engines · Skills · Memory · MCP · Gateway · A2A · AG-UI · A2UI · UCP · AP2 · Mesh · SDK LEGEND CallerGatewayCore EngineMemoryMCPInfrastructureNew ProtocolsRequestResponseMemory I/OTool / Feedback Figure 1. STEM Agent five-layer architecture. Callers interact through the Standard Interface Layer, which routes requests through five protocol handlers (A2A, AG-UI, A2UI, UCP, AP2) and framework adapters to the Agent Core. The core’s cognitive pipeline (Perceive→ Adapt→Skill Match→Reason→Plan→Execute→Learn→Respond) is supported by a four-type Memory System and the MCP Integration Layer for dynamic tool access. complex) based on word count, entity density, and code presence, and extracts entities, sentiment, and urgency. The ADAPT phase loads the caller’s learned profile and ad- justs behavior parameters accordingly. The MATCHSKILLS phase checks the skill registry for acquired skills match- ing the current perception; if a committed or mature skill matches, its pre-built plan is used directly, bypassing REA- SON and PLAN (see Section 5.5 for the full skills lifecycle). Otherwise, SELECTSTRATEGY chooses among four reason- ing strategies based on task characteristics: tool-requiring tasks use ReAct, complex tasks trigger Reflexion, analysis and creative requests use Internal Debate, and all others default to Chain-of-Thought (see Section 5.4 for details). The PLAN phase selects MCP tools and constructs an exe- 3 STEM Agent Algorithm 1 STEM Cognitive Pipeline Input: message m, caller context c Output: response r, updated profile c ′ // Phase 1: Perception p← PERCEIVE(m)▷ intent, entities, complexity // Phase 2: Adaptation θ ← ADAPT(c,p)▷ load profile, adjust params // Phase 3: Skill Match σ ← MATCHSKILLS(p)▷ check acquired skills if σ ̸=∅ and σ 1 .maturity≥ committed then P ← SKILLTOPLAN(σ 1 )▷ short-circuit else // Phase 4: Reasoning s← SELECTSTRATEGY(p,θ) R← REASON(m,p,θ,s) // Phase 5: Planning P ← PLAN(R, MCPTOOLS()) end if // Phase 6: Execution E ← EXECUTE(P)▷ MCP tool calls // Phase 7: Formatting r ← FORMAT(E,θ)▷ style for caller // Phase 8: Learning (async) c ′ ← UPDATEPROFILE(c,p) RECORDSKILLOUTCOME(σ 1 ,E.success) TRYCRYSTALLIZE()▷ pattern→ new skill return r,c ′ cution plan with parallel steps where dependencies allow. EXECUTE orchestrates MCP tool calls with retries (default: 2) and a circuit breaker (threshold: 3 consecutive failures). The LEARNING phase runs asynchronously: it updates the caller profile, records skill activation outcomes (advancing maturity or triggering apoptosis), and attempts to crystallize new skills from accumulated episode patterns. 3.2. Implementation The system is implemented as a TypeScript monorepo with six workspace packages:shared(154+ Zod schemas for runtime type safety),agent-core(cog- nitive engines),standard-interface(protocol han- dlers and gateway),mcp-integration(MCP client layer),memory-system(four memory stores), and caller-layer(caller utilities). The gateway is built on Express.js 5, with each protocol handler mounted via a pluggable createRouter() pattern. 4. Multi-Protocol Interoperability A key contribution of STEM Agent is the simultaneous sup- port for five interaction protocols behind a unified gateway. Table 2 summarizes each protocol. A2A (Agent-to-Agent).Implements the A2A v0.3.0 spec- ification (Linux Foundation) using JSON-RPC 2.0. Sup- portstasks/send,tasks/sendSubscribe(SSE streaming),tasks/get, andtasks/cancel. Agent discovery is served at /.well-known/agent.json. AG-UI(Agent-UserInteraction). Streamscog- nitive pipeline events to frontends via Server-Sent Events.Events includeTEXTMESSAGESTART, REASONINGMESSAGE,TOOLCALLSTART, STATESNAPSHOT, andRUNFINISHED, enabling fine-grained progress rendering. A2UI (Agent-to-User Interface). Provides dynamic UI composition through 16 component primitives organized in a flat adjacency list model where each component references children by ID, enabling flexible layout construction without a fixed widget hierarchy. UCP (Universal Commerce Protocol). Manages check- out session lifecycles with required idempotency head- ers (Idempotency-Key,Request-Id,UCP-Agent). Sessions progress through creation, retrieval, and comple- tion endpoints. An idempotency cache prevents duplicate session creation. AP2 (Agent Payments Protocol). Implements a three- phase payment lifecycle: Intent Mandate→Payment Man- date→Payment Receipt. Supports auto-approval for pay- ments below a configurable threshold and maintains a full audit trail per intent. Gateway architecture. Each protocol handler imple- ments acreateRouter(): Routermethod return- ing an Express.js router. The gateway mounts all routers with shared middleware for authentication, rate limiting, request correlation, and error handling. Adding a new proto- col requires only implementing the handler and mounting its router. Four framework adapters (AutoGen, CrewAI, Lang- Graph, OpenAI Agents SDK) translate external conventions to STEM Agent’s internal format. 5. Self-Adaptation and Learning STEM Agent’s self-adaptation operates at two levels: per- caller profile learning and per-task behavior parameter tun- ing. 4 STEM Agent Table 2. Protocol comparison. STEM Agent implements all five behind a single Express.js gateway. A2A follows the Linux Foundation v0.3.0 specification. UCP and AP2 are novel protocols proposed in this work. ProtocolEndpointTransportSchemasUse Case A2A POST /a2aJSON-RPC 2.06Agent-to-agent task delegation, inter-agent messaging, agent card discovery AG-UI POST /ag-uiSSE20Real-time UI streaming; maps pipeline phases to typed events A2UI POST /a2ui/renderSSE + REST19 Dynamic UI composition with 16 compo- nent primitives UCP POST /ucp/ * REST14Commerce checkout sessions with idempo- tency AP2 POST /ap2/ * REST10Mandate-based payments with audit trail Table 3. Caller Profile dimensions by category. CategoryDimsExample Dimensions Philosophy8pragmatism vs. idealism, risk tolerance, innovation orientation Principles4correctness over speed, testing emphasis, security mindedness Style5 formality, verbosity, techni- cal depth, structure prefer- ence Habits4+session length, iteration ten- dency, peak hours 5.1. Caller Profiler The Caller Profiler learns a multi-dimensional model of each user across four categories (Table 3): philosophy (8 dimensions, e.g., pragmatism vs. idealism, risk tolerance), principles (4 dimensions, e.g., correctness over speed, test- ing emphasis), style (5 dimensions, e.g., formality, verbosity, technical depth), and habits (temporal and behavioral pat- terns). Learning mechanism. Each dimension is updated via an exponential moving average (EMA) with learning rate α = 0.1: v t+1 = (1− α)· v t + α· s t (1) wherev t is the current profile value ands t is the signal extracted from the current interaction. We choseα = 0.1 to balance responsiveness to new signals against stability of learned preferences; smaller values (e.g., 0.05) produced sluggish adaptation in preliminary testing, while larger val- ues (e.g., 0.3) caused oscillation. Confidence-gated adaptation.Profile confidence follows a rational saturation curve: conf(n) = n n + κ (2) wherenis the number of interactions andκ = 10is a half- life constant (conf reaches 0.5 atn = κ). Belown = 5 (conf≈ 0.33), the system relies primarily on signals from the current message; as confidence grows, the learned profile is blended with current signals weighted by confidence. 5.2. Behavior Parameters Ten parameters are continuously adjusted based on task characteristics and caller profile: reasoning depth (default: 3), exploration vs. exploitation (0.3), verbosity (0.5), confi- dence threshold (0.7), tool use preference (0.5), creativity (0.5), proactive suggestion (on), self-reflection frequency (every 5 steps), max plan steps (10), and memory retrieval breadth (10). The Adaptation phase adjusts these using the caller profile and current task perception as inputs. 5.3. Memory System The memory system implements four complementary types informed by recent agent memory research (Ai et al., 2025; Gallego, 2026): 1.Episodic memory: Stores specific interaction episodes with vector embeddings for similarity search (Post- greSQL + pgvector). Each episode carries an impor- tance score. 2.Semantic memory: Maintains knowledge triples (sub- ject, predicate, object) in concept graphs, with patterns extracted from episodic memory. 3. Procedural memory: Records successful strategies and tool usage patterns, enabling best-procedure match- ing for recurring task types. 4. User context memory: Per-caller session history and profiles with GDPR forget-me support. A Memory Manager provides a unified facade, delegating to specialized modules and performing memory consolida- tion (episodic→semantic/procedural) as interaction history grows. 5 STEM Agent 5.4. Reasoning Strategy Selection The Strategy Selector maps task characteristics to reasoning strategies via deterministic rules: • Tool-requiring tasks→ ReAct (Wei et al., 2026) •Complexity = complex→Reflexion (Wei et al., 2026) •Analysis or creative requests→Internal Debate (Tran et al., 2025) • Default→ Chain-of-Thought (Wei et al., 2026) These rules are deliberately simple; the classification of task complexity and intent (computed during the Perception phase) provides the necessary signal. We note that this selection logic is not externalized via MCP—it is meta- reasoning that we consider part of the agent core rather than domain knowledge. 5.5. Skills Acquisition via Cell Differentiation Extending the stem cell metaphor, we model skill acquisi- tion as cell differentiation: internal cues (episodic memory patterns, procedure success rates) and external cues (MCP tool availability, caller domain signals) trigger crystalliza- tion of specialized skills. A skill encapsulates a trigger condition (intent patterns, domains, entity types), an action sequence (tool chain or procedure steps), and maturity meta- data. Skills progress through three stages mirroring cell lineage: 1.Progenitor: newly crystallized from episode patterns; not yet used for shortcutting. 2.Committed: afterk c =3successful activations with success rate≥0.6; can short-circuit the Reason→Plan pipeline. 3.Mature: afterk m =10successful activations; receives matching priority. Crystallization and apoptosis. The Learn phase groups recent episodes by action patterns; when≥3episodes share a common action key and topic keywords appear in≥50% of episodes, a progenitor skill is created. Conversely, crys- tallized skills with success rate<0.3after≥10activations are removed (apoptosis). Users can also manually register or remove plugin skills (induced differentiation), bypassing the crystallization process. 6. Evaluation 6.1. Test Suite and Protocol Compliance The test suite comprises 413 tests across 37 test files using Vitest, with 100% pass rate and a total runtime of 2.92 s. Table 4. Architectural comparison with existing agent frameworks. Proto. = standardized interoperability protocols; Adapt = per-caller self-adaptive behavior; Mem. = distinct memory subsystem types; Skills = emergent skill acquisition; Com. = commerce protocols. †UCP and AP2 are novel protocols proposed in this work. FrameworkProto.AdaptMem.SkillsCom. AutoGen1×1× MetaGPT1×1× CrewAI1×1× LangChain1×2× STEM3+2 † ✓4✓ Tests cover unit tests per engine (perception, reasoning, plan- ning, execution, skills acquisition), protocol handler integra- tion tests (verifying A2A JSON-RPC compliance, AG-UI event sequences, UCP idempotency, AP2 audit trails), mem- ory system tests, MCP integration tests, security middleware tests, framework adapter tests, and gateway end-to-end tests. While test count alone does not guarantee correctness, the breadth of coverage across all five layers provides confi- dence in cross-component integration. 6.2. Architectural Overhead Analysis Each protocol handler adds a thin routing and serializa- tion layer atop the shared cognitive pipeline. A2A requires JSON-RPC envelope parsing and task state management. AG-UI requires only SSE channel setup. A2UI adds compo- nent tree construction and layout validation. UCP adds idem- potency key lookup and checkout state management. AP2 adds mandate validation and audit trail writes. Since all han- dlers delegate to the same Agent Core pipeline with mocked LLM inference, protocol-specific overhead is dominated by serialization and middleware traversal rather than com- putation. Formal latency benchmarking under controlled conditions is left to future work. 6.3. Framework Comparison Table 4 compares STEM Agent with existing frameworks across architectural dimensions (feature comparison, not performance benchmark). We count “standardized protocols” as those with published, externally-maintained specifications. STEM Agent imple- ments three established protocols (A2A v0.3.0, AG-UI, MCP) plus two novel ones (UCP, AP2), validated through integration tests verifying event sequences, error handling, and idempotency. The pluggable IAM architecture supports four authentication plugins (JWT, OAuth2, SAML, API Key) with TTL-based policy caching and configurable rate limiting. 6 STEM Agent 7. Limitations No end-to-end benchmark evaluation. Our evaluation validates compliance through testing but does not include task-completion benchmarks (e.g., MAFBench (Orogat et al., 2026)) or user studies. Adaptation simplicity: The EMA-based Caller Profiler cannot capture non-stationary or multi-modal preference distributions. Commerce protocol maturity: UCP and AP2 lack external adoption and formal threat modeling. Scalability: In-memory stores for profiles and idempotency caches require distributed locking under high concurrency. 8. Conclusion and Future Work We have presented STEM Agent, demonstrating that proto- col plurality, behavioral self-adaptation, and emergent skill acquisition can coexist when external capabilities are medi- ated by MCP and user modeling is decoupled from domain logic. The biologically-inspired skills system extends the stem cell metaphor to runtime behavior: the agent crystal- lizes reusable skills from recurring patterns, with maturation and apoptosis ensuring quality. Future work includes: STEM Platform, an orchestration layer that dynamically integrates and composes multiple STEM Agents into complex, multi-agent projects through delegation, consensus, and pipeline collaboration patterns; benchmark evaluation (Orogat et al., 2026; Luo et al., 2025); learned strategy selection via adaptive test-time compute (Alomrani et al., 2025); interoperability with ANP (Chang et al., 2025) and AWCP (Nie et al., 2026); embedding-based skill matching and cross-session skill transfer; and formal threat modeling for UCP/AP2 (Shen et al., 2026; Anbiaee et al., 2026). Impact Statement This paper presents work whose goal is to advance the field of AI agent systems. The STEM Agent architec- ture is designed for transparency (audit logging, explain- able adaptation) and user control (GDPR forget-me sup- port, configurable autonomy levels). As with any agent framework, deployment should consider safety boundaries, particularly when commerce protocols handle financial transactions. We encourage adopters to implement ap- propriate guardrails for their deployment context. The source code is available athttps://github.com/ alfredcs/stem-agent under the MIT License. References Ai, Q., Tang, Y., Wang, C., Long, J., Su, W., and Liu, Y.MemoryBench: A benchmark for memory and continual learning in LLM systems.arXiv preprint arXiv:2510.17281, 2025. Alomrani, M. A., Zhang, Y., Li, D., Sun, Q., Pal, S., Zhang, Z., Hu, Y., Ajwani, R. D., Valkanas, A., et al. Reasoning on a budget: A survey of adaptive and controllable test- time compute in LLMs. arXiv preprint arXiv:2507.02076, 2025. Anbiaee, Z., Rabbani, M., Mirani, M., Piya, G., Opushnyev, I., Ghorbani, A., and Dadkhah, S. Security threat mod- eling for emerging AI-agent protocols: A comparative analysis of MCP, A2A, Agora, and ANP. arXiv preprint arXiv:2602.11327, 2026. Chang, G., Lin, E., Yuan, C., Cai, R., Chen, B., Xie, X., and Zhang, Y. Agent network protocol technical white paper. arXiv preprint arXiv:2508.00007, 2025. Dang, Y., Qian, C., Luo, X., Fan, J., Xie, Z., Shi, R., Chen, W., Yang, C., Che, X., Tian, Y., et al. Multi-agent col- laboration via evolving orchestration. arXiv preprint arXiv:2505.19591, 2025. Drammeh, P. Multi-agent LLM orchestration achieves de- terministic, high-quality decision support for incident response. arXiv preprint arXiv:2511.15755, 2025. Ehtesham, A., Singh, A., Gupta, G. K., and Kumar, S. A survey of agent interoperability protocols: Model context protocol (MCP), agent communication protocol (ACP), agent-to-agent protocol (A2A), and agent network proto- col (ANP). arXiv preprint arXiv:2505.02279, 2025. Fan, S., Ding, X., Zhang, L., and Mo, L. MCPToolBench++: A large scale AI agent model context protocol MCP tool use benchmark. arXiv preprint arXiv:2508.07575, 2025. Ferrag, M. A., Tihanyi, N., and Debbah, M. From LLM reasoning to autonomous AI agents: A comprehensive review. arXiv preprint arXiv:2504.19678, 2025. Gallego, V. Distilling feedback into memory-as-a-tool. arXiv preprint arXiv:2601.05960, 2026. Habler, I., Huang, K., Narajala, V. S., and Kulkarni, P. Build- ing a secure agentic AI application leveraging A2A pro- tocol. arXiv preprint arXiv:2504.16902, 2025. Hasan, M. M., Li, H., Rajbahadur, G. K., Adams, B., and Hassan, A. E. Model context protocol (MCP) tool descrip- tions are smelly! towards improving AI agent efficiency with augmented MCP tool descriptions. arXiv preprint arXiv:2602.14878, 2026. Jayanti, M. A. and Han, X. Y. Enhancing model context protocol (MCP) with context-aware server collaboration. arXiv preprint arXiv:2601.11595, 2026. 7 STEM Agent Jeong, C. A study on the MCP x A2A framework for enhancing interoperability of LLM-based autonomous agents. arXiv preprint arXiv:2506.01804, 2025. Li, J., Zhao, W., Zhang, Y., and Gan, C.Steering LLM thinking with budget guidance. arXiv preprint arXiv:2506.13752, 2025. Li, Q. and Xie, Y. From glue-code to protocols: A critical analysis of A2A and MCP integration for scalable agent systems. arXiv preprint arXiv:2505.03864, 2025. Lumer, E., Gulati, A., Subbiah, V. K., Basavaraju, P. H., and Burke, J. A. ScaleMCP: Dynamic and auto-synchronizing model context protocol tools for LLM agents. arXiv preprint arXiv:2505.06416, 2025. Luo, Z., Shen, Z., Yang, W., Zhao, Z., Jwalapuram, P., Saha, A., Sahoo, D., Savarese, S., Xiong, C., and Li, J. MCP-Universe: Benchmarking large language models with real-world model context protocol servers. arXiv preprint arXiv:2508.14704, 2025. Nie, X., Guo, Z., Chen, Y., Zhou, Y., and Zhang, W. AWCP: A workspace delegation protocol for deep-engagement collaboration across remote agents.arXiv preprint arXiv:2602.20493, 2026. Orogat, A., Rostam, A., and Mansour, E. Understanding multi-agent LLM frameworks: A unified benchmark and experimental analysis. arXiv preprint arXiv:2602.03128, 2026. Sarkar, A. and Sarkar, S. Survey of LLM agent communica- tion with MCP: A software design pattern centric review. arXiv preprint arXiv:2506.05364, 2025. Schlapbach, A. The convergence of schema-guided dialogue systems and the model context protocol. arXiv preprint arXiv:2602.18764, 2026. Shen, Y. T., Toyoda, K., and Leung, A. MCP-38: A com- prehensive threat taxonomy for model context protocol systems (v1.0). arXiv preprint arXiv:2603.18063, 2026. Tran, K.-T., Dao, D., Nguyen, M.-D., Pham, Q.-V., O’Sullivan, B., and Nguyen, H. D. Multi-agent collabo- ration mechanisms: A survey of LLMs. arXiv preprint arXiv:2501.06322, 2025. Wei, T., Li, T.-W., Liu, Z., Ning, X., Yang, Z., Zou, J., Zeng, Z., Qiu, R., Lin, X., Fu, D., et al. Agentic reasoning for large language models. arXiv preprint arXiv:2601.12538, 2026. Yadav, A. G., Dherange, V., and Shivam, K. Project synapse: A hierarchical multi-agent framework with hybrid mem- ory for autonomous resolution of last-mile delivery dis- ruptions. arXiv preprint arXiv:2601.08156, 2026. 8