Nelson Lin, AI Agent Engineer, founder of three AI startups (ex-Tencent / Citi ) - 7+ years building ML / AI agent systems.
What Is Vibe Coding in 2026? Vibe coding is the practice of building software by describing the desired “feel” and intent in natural language to AI agents, then accepting, iterating, or steering the generated code with minimal manual typing. Coined ...
As AI agents like OpenAI's Codex and Anthropic's Claude write millions of lines of code autonomously, traditional software engineering is evolving. The critical skill isn't prompting models better. It's engineering the "harness" around them. What I...
In March 2026, during Perplexity's Ask 2026 developer conference, CTO Denis Yarats announced that the company is moving away from Anthropic's Model Context Protocol (MCP) for its internal systems and enterprise-facing operations. Instead, Perplexity is prioritizing traditional REST APIs and command-line interfaces (CLIs), while also rolling out new tools like their multi-model Agent API. This shift doesn't mean abandoning MCP entirely. Perplexity continues to support it for certain use cases, such as enabling local desktop tools like Claude to access Perplexity's real-time search. However, for production-scale, mission-critical, and customer-facing workloads, the protocol no longer meets the company's reliability, efficiency, and security requirements. What Is MCP and Why Was It Promising? Introduced by Anthropic in late 2024, the Model Context Protocol is an open standard designed to standardize how AI agents and large language models interact with external tools, data sources, and services. It acts as a universal interface and often described as "USB-C for AI", allowing models to discover, describe, and call tools without custom integrations for each one. MCP servers typically run locally or remotely, communicating via transports like stdio or HTTP, and have powered integrations in tools such as Claude Desktop, Cursor, and VS Code. Perplexity previously maintained an official MCP server to let users plug its search capabilities directly into compatible AI clients, and that support remains active. The Key Reasons for the Internal Shift Perplexity's decision stems from practical challenges encountered when scaling MCP beyond lightweight or local development environments. The main issues include: Context Window Overhead and Token Inefficiency MCP interactions often require loading extensive tool schemas, descriptions, traces, and metadata into the model's context for every call. This leads to significant token consumption, sometimes adding tens of thousands of tokens per interaction—driving up costs and latency. In high-volume or complex agentic workflows, this "token bloat" becomes a major bottleneck. Authentication and Security Friction Enterprise clients demand robust features like OAuth flows, granular permissions, rate limiting, audit logs, and secure credential management. MCP lacks strong built-in support for these, making it difficult to enforce enterprise-grade security across multiple tool servers. Traditional REST APIs, with decades of mature tooling for authentication and observability, handle these requirements far more reliably. Reliability and Performance at Scale The protocol's default transports (especially stdio) work well for single-machine, local setups but introduce unpredictability, higher latency, and monitoring difficulties in distributed or production environments. Agent behavior can become non-deterministic when models decide tool usage, leading to inconsistent outcomes compared to the deterministic nature of direct API or CLI calls. These limitations make MCP ideal for rapid prototyping, local dev tooling, and niche integrations but less suitable for anything requiring production stability, cost efficiency, or strict compliance. What Perplexity Is Using Instead For internal operations and larger clients, the company has returned to battle-tested REST APIs, which excel in security, scalability, and predictability. They've complemented this with CLIs for streamlined execution in certain workflows. At the same conference, Perplexity launched an expanded API platform, including: Agent API : A managed runtime for agentic workflows with built-in orchestration, retrieval, tool execution, and multi-model routing (supporting models from OpenAI, Anthropic, Google, xAI, NVIDIA, and more). Supporting APIs for embeddings, sandboxed code execution, and search. These tools provide the flexibility of agent-like behavior (multi-step reasoning, tool use) without the protocol overhead, positioning APIs as the foundational layer rather than something wrapped by MCP. The Broader Implications Perplexity's move highlights a maturing phase in agentic AI: early hype around universal protocols like MCP gave way to real-world engineering trade-offs. While MCP remains valuable for lightweight, local, or open-ecosystem scenarios, production demands, especially in enterprise settings favor simpler, more controllable primitives like APIs and CLIs. The protocol isn't "dead"; its maintainers continue evolving it (with roadmaps addressing production concerns), and it retains utility in specific niches. But Perplexity's high-profile shift sends a clear signal: for anything important—scale, security, cost, reliability. The established stack still wins. In short, this isn't rejection of innovation. It's prioritization of what works at Perplexity's level of ambition and responsibility to enterprise users.
Hi, I'm Nelson LIN. Discover the complete AI agent engineer tech stack I use daily to ship reliable, autonomous agents – including LangChain, LangGraph, Next.js, Vercel AI SDK , and more. 1. Programming Languages for AI Agent Development Python for AI Agents : The #1 language for backend logic, LLM orchestration, agent tools, and all things AI/ML. Essential for production AI agents. TypeScript : Ensures type-safe, maintainable code for frontend agent interfaces and full-stack agent apps. 2. Best Frontend Frameworks for AI Agent UIs Next.js 16 : Build fast, SEO-optimized, interactive UIs for AI agents with React Server Components and App Router. Vercel AI SDK : Top frontend framework for AI agents. Streamlines LLM responses, tool calls, and conversational UIs effortlessly. 3. Backend & AI Agent Frameworks (Production-Ready) FastAPI : High-performance Python backend with async support, auto OpenAPI docs – perfect for agent APIs. LangChain : Essential for chains, RAG, tools, memory, and basic agents in production AI apps. LangGraph : Advanced stateful multi-agent workflows with cycles, persistence, and human-in-the-loop. Pydantic AI : Enforce structured LLM outputs and type safety for reliable, production AI agents. 4. Context Engineering & Data Stack for AI Agents Proven data layer for long-term memory, session state, and context retrieval in AI agents. LangChain : Memory, retrievers, and context assembly for intelligent agents. PostgreSQL : Relational DB for structured data, user sessions, and consistent long-term agent memory. Prisma ORM : Type-safe PostgreSQL access from TypeScript for full-stack AI apps. MongoDB : Flexible docs for agent state, tool histories, and RAG documents. Redis : In-memory caching for real-time agent sessions, rate limits, and working memory. 5. Cloud Infrastructure for Scalable AI Agents AWS : Enterprise cloud for compute, databases, serverless – scales AI agents globally. Vercel : Frictionless Next.js + AI SDK deployments with edge functions and auto-scaling. AWS Solutions Architect Certified : Designs secure, cost-optimized agent architectures. 6. AI-Powered Development Tools for Agent Engineers Cursor AI IDE : AI-assisted coding for faster agent prototyping and debugging. Trae AI IDE ( ): Autonomous agents that understand your full codebase. Why This AI Agent Tech Stack Dominates in 2026 Key advantages for building production AI agents : Full Type Safety : TypeScript + Pydantic AI + Prisma prevents agent errors at scale. Seamless Streaming UIs : Vercel AI SDK + LangChain for real-time agent interactions. Enterprise Orchestration : LangGraph + FastAPI for complex multi-agent systems. Scalable Infrastructure : AWS + Vercel for any agent workload. From customer support agents to research systems and multi-agent platforms, this AI agent tech stack accelerates prototype-to-production by weeks. Keywords : AI agent stack, LangGraph tutorial, production AI agents, agent engineering tools. Deep into AI agents, RAG, memory architecture, or LangChain/LangGraph ? Connect on for agent patterns, vector DB tradeoffs, and cutting-edge tooling discussions!
What is Agent Engineering? At its core, agent engineering is the process of turning a non-deterministic AI model into a reliable production system. It moves beyond simple "prompting" to "orchestrating" complex loops where an agent: Observes the environment or user input. Reasons about the information and breaks down tasks. Plans the next steps, including selecting which tools to use. Acts by executing tools (APIs, code, or searches). Reflects on the results and iterates until the goal is met. This discipline is highly iterative—it requires a continuous cycle of building, testing, observing, and refining to ensure the agent behaves predictably in unpredictable real-world scenarios. Essential Skills for an Agent Engineer To succeed in this role, you need a hybrid skillset that spans traditional software engineering, data science, and "AI-native" thinking. 1. Software & Systems Engineering Agents are essentially complex software applications. You must be proficient in: Programming : Mastery of Python is critical, as most agent frameworks (like and ) are Python-based. Infrastructure : Building "harnesses" that handle durable execution , human-in-the-loop pauses (where an agent waits for a person's approval), and asynchronous task management. Tool Integration : Writing secure and efficient interfaces for agents to interact with external APIs, databases, and file systems. 2. AI Architecture & Orchestration An Agent Engineer doesn't just write code; they design "cognitive architectures." Control Flow Design: Knowing when to use a Directed Acyclic Graph (DAG) for rigid workflows versus a Cyclic Graph (like LangGraph) for agents that need to loop back and retry tasks. Multi-Agent Orchestration: Designing "Boss-Worker" or "Peer-to-Peer" patterns. You must know how to partition tasks so one agent handles specialized research while another handles final synthesis without losing context. State Management: Mastering "Durable Execution." If an agent task takes 10 minutes or requires a human approval, the engineer must ensure the system can "sleep" and resume without losing its place or doubling API costs. 3. Advanced Tool & Context Engineering Agents are only as good as their "hands" (tools) and "memory" (context). Tool Definition & Schema Design: Writing precise JSON schemas for functions. If a tool's description is vague, the agent will hallucinate parameters. An engineer must "prime" tools so the LLM understands exactly when and how to call them. Dynamic Context Injection: Moving beyond basic RAG (Retrieval-Augmented Generation). This involves Agentic RAG , where the agent decides which document chunks to read based on its current progress, rather than just pulling the top 3 results blindly. Short-term vs. Long-term Memory: Implementing "sliding window" buffers so the agent doesn't forget the original goal during a long, 20-turn conversation. 3. Evaluation & Data Science (The "Evals" Mindset) Because agents are non-deterministic, you cannot test them with traditional unit tests alone: Evaluation Engineering : Developing "evals" to measure how often an agent achieves its "job to be done" versus how often it "hallucinates" or fails a task. Observability & Tracing : Using tools like LangSmith or to trace the exact "thought process" and tool calls an agent made during a failure. 4. Product Thinking & Design Defining Scope : Understanding exactly what "job" the agent is replicating and setting boundaries so it doesn't overreach or go off-track. Safety & Ethics : Implementing guardrails to prevent prompt injection attacks or unintended actions in sensitive environments. Conclusion Agent engineering is rapidly evolving as AI models become more capable and integrated into production systems. Mastering the blend of software engineering, AI orchestration, rigorous evaluation, and product‑centric thinking enables engineers to build agents that are reliable, safe, and valuable. As the field matures, we can expect stronger standardization of evals, shared memory systems, and emerging frameworks that further reduce the gap between prototype and deployable AI agents.
GitHub: Discover the scalable, observable architecture powering – autonomous AI agents collaborating like a hedge fund. Explore 6 foundational decisions for AI trading success: hierarchical agents, LangChain middleware, Prisma context, Alpaca data, Redis streaming, and AWS Batch scaling. 1. Supervisor-Subagent Collaboration: Hierarchical Orchestration for Robust Trading Decisions Why Hierarchical Agents Beat Single-Agent Systems sandx.ai deploys a supervisor-subordinate topology mimicking investment committees: 1 Chief Investment Officer (CIO) agent orchestrates 7 specialist analysts (Technical, Fundamental, Sentiment, Risk, etc.). The CIO decomposes tasks, routes to experts, and synthesizes outputs via multi-agent voting – resolving conflicts for superior signal quality over monolithic agents. "Single agents hallucinate. Teams deliberate." – sandx.ai architecture principle 2. LangChain v1 Middleware: Session Restore & Live Streaming Logging Custom Middleware for Production Observability LangChain v1.0 middleware intercepts every agent step for auto-logging to database – enabling live chat streaming and session restore . Tracking agent behavior with logging, analytics, and debugging. Adding , , and early termination logic. Key benefits: debugging at scale , user session continuity , real-time monitoring without performance overhead. 3. Prisma ORM Context Management: Type-Safe AI Memory Why Prisma Powers Reliable Multi-Agent Context Trading agents need consistent context : portfolios, strategies, histories. Prisma delivers: Prisma ORM make our context Type-Safe, Productive, Query-Powerful. Result: Zero-downtime schema evolution + query power without SQL complexity. Compile-time validation : Prisma's generated types catch invalid field access, missing relations, or schema mismatches during development—not in production trading. Safe refactoring : Catch error early before deploy to the production. Schema as single source of truth : Context model changes automatically propagate type updates, preventing regressions when evolving agent logic Type Hints: Accelerate Development IDE autocomplete for context fields and relations reduces lookup time and speeds iteration. Avoid writing complex SQL : With layer of Prisma ORM, writing better query without digging into complex SQL. Simple CRUD: Efficient Context Lifecycle Atomic updates : Trading requires atomic updates when buy or sell stocks. Nested operations : Prisma handles relational writes seamlessly—persisting complex agent workflows without boilerplate. 4. Alpaca Market Data: Institutional-Grade Real-Time Feeds 10K RPM Limits Enable Agent Parallelism Single-source truth eliminates data silos – all agents reason from identical market reality. Integrating Alpaca, agents operate on consistent, low-latency, institutional-grade data, turning market complexity into actionable intelligence. 5. Redis Multi-Region: Sub-Second Global UI Updates Simple Polling + Geo-Replication = Responsive UX Agents → Redis → Frontend polling (1-2s intervals). Multi-region replication ensures <100ms latency worldwide. Multi-Region Replication for Global Low Latency Regional Redis Replicas : Agent messages are stored in Redis instances replicated across multiple geographic regions. Users connect to their nearest replica, minimizing network round-trip time. Automatic Failover : If a regional endpoint experiences issues, traffic routes to the next closest replica—ensuring consistent UI responsiveness worldwide. Simple Polling, High Performance No WebSockets complexity, just Redis performance. Stream Buffering: Protecting the Database Write-Ahead Buffer : Agents write messages to Redis first; a background worker asynchronously persists to Prisma/PostgreSQL. This decouples real-time delivery from durable storage. Reduced DB Load : High-frequency agent thoughts, tool calls, and status updates hit Redis, not the primary database, preventing query contention during active trading sessions. 6. AWS Batch: Pay-Per-Job Agent Execution Perfect for I/O-Bound AI Workloads Agents spend 90% time waiting (LLMs, APIs, DB). AWS Batch: I/O-Bound vs. CPU-Intensive Waiting, Not Computing: Agents spend most cycles waiting on LLM responses, third-party API calls (Alpaca, OpenRouter), and database queries—not performing heavy local computation. Idle Resource Waste: Traditional always-on servers or oversized containers pay for CPU cycles that sit idle during these wait periods. Operational Efficiency Event-Driven Scaling: Jobs queue and execute only when triggered (market events, user requests), scaling to zero during idle periods. Managed Infrastructure: No Kubernetes clusters or EC2 fleets to manage—AWS Batch handles provisioning, scheduling, and termination automatically Event Driven & Job Queuing Automatic Queue Management: When triggered, jobs enter a managed queue. AWS Batch holds them there until the allocated compute resources become available. On-Demand Invocation: The AWS Batch SDK allows the backend to instantly trigger agent jobs with specific parameters (e.g., ticker=AAPL) in response to real-time events like cron schedule, or user interactions. Choosing agent-favor and event-driven solutions with job queuing solution allows to built a scalable and low cost agent-runtime solution for heavy multi-agent workflows. Architecture = Alpha: Why sandx.ai Wins Powerful models alone fail. sandx.ai succeeds through purpose-built infrastructure: Intelligent orchestration that mirrors human expertise structures Observable middleware that builds trust through transparency Robust context management that ensures decision consistency Real-time communication that delivers interactive user experiences Reliable market data that grounds AI reasoning in reality Cost-aware compute that scales with workload demands By thoughtfully integrating these six pillars, we've built a platform where AI agents don't just trade, they reason, collaborate, and evolve. The result is a system that combines the speed of algorithms with the wisdom of structured decision-making. .
