Moving Beyond the Prompt: A Developer’s Guide to Agentic AI Architecture

Deepanshu Verma — Tue, 19 May 2026 07:56:24 +0000

If you open LinkedIn or X right now, you can’t throw a rock without hitting an "AI Guru" talking about how Agentic AI is going to replace every software engineer by next Tuesday.

As developers, we’ve learned to filter out the marketing fluff. When LLMs first dropped, most of us built the standard integration: a React frontend captures user input, sends it to a Node.js/Express backend, the backend hits an API endpoint (like OpenAI or Anthropic), and we pipe the response back to the UI.

It's essentially a glorified fetch() request with a fancy system prompt.

But Agentic AI is fundamentally different. It isn’t just a bigger prompt; it’s a shift in software architecture. Let’s break down what actually makes an AI "agentic," how it changes your backend workflow, and what a basic implementation looks like.

The Core Shift: Linear vs. Iterative Loops

To understand Agentic AI, we have to look at how control flow works.

The Standard AI Pipeline (Linear)In a traditional LLM feature, the execution path is predictable.
Input --> LLM Processing -->Output
If the LLM returns hallucinated data or a broken JSON string, your app crashes, or the user gets a garbage response. The system has no self-awareness.

The Agentic Workflow (Looping) An agent operates on a Reasoning and Acting (ReAct) pattern. Instead of spitting out an answer instantly, it runs in a loop:

Think: Analyze the user's goal and break it down into smaller sub-tasks.
Act: Execute a specific action (like running a database query, fetching an external API, or reading a file).
Observe: Analyze the output of that action. Did it work? Did it get the required data?Iterate: Repeat until the goal is met.

[User Goal] ──> [ Think ] ──> [ Act (Call Tool) ]
                   ▲                  │
                   │                  ▼
                   └─────────── [ Observe Result ]

The Anatomy of an AI Agent

If you want to build an agentic backend (whether you're using Node.js/TypeScript or Python), your system needs three foundational pillars:

State Management (Memory)Agents need to remember what they did three steps ago. This isn't just chat history; it’s a structured state that tracks:

The original objective.
The tools that have already been executed.
The execution logs of those tools.

Tools (The Agent's Hands)An LLM by itself is just a calculator predicting the next word. It can't check the weather, it can't query your MongoDB instance, and it can't execute a bash command.Tools are functions you write that you expose to the LLM. You give the LLM a JSON schema describing what the function does and what parameters it expects. The LLM then decides when and how to call it.
The Planning Engine (The Brain)This is where the LLM uses frameworks like LangChain, LangGraph, or custom code to evaluate if the current state matches the user’s definition of "done."What This Looks Like in CodeLet’s look at a conceptual example of how you might declare a tool and let an LLM decide to use it in a Node.js/TypeScript environment. Instead of writing complex wrapper logic, we can leverage function calling.TypeScriptimport { OpenAI } from "openai";

const openai = new OpenAI();

// 1. Define a tool the agent can use
const tools = [
  {
    type: "function" as const,
    function: {
      name: "queryUserDatabase",
      description: "Fetches user profile data from MongoDB using an email address.",
      parameters: {
        type: "object",
        properties: {
          email: { type: "string", description: "The email of the user to look up" },
        },
        required: ["email"],
      },
    },
  },
];

async function runAgent(userPrompt: string) {
  // 2. Initial "Think" step
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: userPrompt }],
    tools: tools,
  });

  const toolCalls = response.choices[0].message.tool_calls;

  if (toolCalls) {
    for (const toolCall of toolCalls) {
      if (toolCall.function.name === "queryUserDatabase") {
        // Parse arguments provided by the LLM
        const args = JSON.parse(toolCall.function.arguments);

        console.log(`Agent decided to act: Querying DB for ${args.email}`);
        // 3. Execute the action
        const dbResult = await internalMongoQuery(args.email); 

        // 4. Feed the observation back to the LLM to get the final answer
        const finalResponse = await openai.chat.completions.create({
          model: "gpt-4o",
          messages: [
            { role: "user", content: userPrompt },
            response.choices[0].message,
            {
              role: "tool",
              tool_call_id: toolCall.id,
              content: JSON.stringify(dbResult),
            },
          ],
        });

        return finalResponse.choices[0].message.content;
      }
    }
  }

  return response.choices[0].message.content;
}

The Developer Realities of Going Agentic

While agentic AI is incredibly powerful for handling complex, non-linear workflows (like automated debugging, data analysis, or complex customer support routing), it introduces a massive set of engineering challenges:

Latency: A standard API call takes 1–2 seconds. An agent looping through three different tools to solve a problem can easily take 10–30 seconds. You have to completely rethink your UI/UX—think WebSockets and granular loading states.
Token Costs: Because the agent passes the entire history, state, and tool schemas back and forth through every loop iteration, token consumption scales exponentially.
Infinite Loops: If an agent encounters a broken tool or an unexpected payload, it can get stuck in an execution loop, burning through your API budget in minutes. Strict iteration limits (e.g., max 5 loops) are mandatory.

Agentic AI isn't magic; it's a design pattern where the LLM controls the execution path of your code based on real-time feedback.As full-stack developers, our job is shifting from writing linear, rigid pipelines to building the sandboxes, tools, and guardrails that allow these agents to operate safely and efficiently.Have you started building agentic features into your stack yet? What frameworks (LangGraph, CrewAI, Autogen) are you exploring?

Building a Remote Health Monitor: Integrating rPPG with React and Python

Deepanshu Verma — Tue, 12 May 2026 08:48:33 +0000

The Technical Architecture: Bridging React and Python
One of the biggest hurdles in this project was managing the data flow. Python is the king of Computer Vision, but React is the king of User Experience. To make them talk to each other efficiently, I built a decoupled system.

The Frontend (The Collector)
Using React.js, I implemented a custom hook to handle the MediaDevices API. The challenge wasn't just showing the video; it was capturing frames at a consistent interval and shipping them to the backend without blocking the UI thread.
The Backend (The Processor)
The heart of the app is a Python server. I chose Python specifically to leverage the open-rppg library and OpenCV.

Processing Pipeline: The backend receives the frame, applies skin-tone detection, and calculates the remote photoplethysmography (rPPG) signal.

API Design: I built a lightweight RESTful interface (or WebSocket for real-time) to handle the inference results.

The Deployment (The Reality Check) This is where the engineering got "scrappy." While deploying the backend on Render, I hit a 512MB memory limit—common when running heavy Python libraries.

The Solution: I containerized the backend using Docker. This allowed me to optimize the environment, prune unnecessary dependencies, and manage memory usage more deterministically.

# A snippet showing how we handle the incoming frame
def process_vital_signals(frame_data):
    # Decode base64 frame from React frontend
    frame = decode_base64_to_cv2(frame_data)

    # Run rPPG inference
    vitals = rppg_engine.estimate_heart_rate(frame)

    return {
        "bpm": vitals.bpm,
        "confidence": vitals.score,
        "timestamp": time.time()
    }

DEV Community: Deepanshu Verma

Moving Beyond the Prompt: A Developer’s Guide to Agentic AI Architecture

Building a Remote Health Monitor: Integrating rPPG with React and Python