The development era shifted from **chat UIs** to **agentic systems** that call tools, read repos, and execute workflows. Here's the stack I actually ship with in 2026.

## LLM landscape (what I use and why)

| Model family | Best for | Production notes |
|--------------|----------|------------------|
| **GPT-4o / o-series** | General reasoning, multimodal | Strong tool calling; watch token cost at scale |
| **Claude (Anthropic)** | Long context, careful codegen | Excellent for refactors and spec adherence |
| **Gemini** | Google ecosystem integrations | Good when GCP-native |
| **Llama / Qwen (via Ollama)** | Local-first, privacy, job automation | Zero cloud bill; tune prompts per hardware |
| **Open-weight (HF)** | Fine-tune & domain agents | Pair with LangGraph for guardrails |

No single winner — I route by **latency, cost, privacy, and tool compatibility**.

## Model Context Protocol (MCP)

**MCP** standardizes how agents connect to databases, APIs, and IDEs. Instead of bespoke integrations per tool, you expose **resources + tools** once. This is why Cursor, Claude Desktop, and platform teams are converging on MCP servers for:

- Postgres / commerce APIs
- GitHub PR workflows
- Internal admin panels

## Agent patterns that survive production

1. **Graphs over chains** — LangGraph state machines with explicit human gates
2. **Tool allowlists** — never give agents open network access
3. **Observability** — log every tool call with correlation IDs
4. **Fallback paths** — keyword routers when LLM confidence is low (social commerce order lookups do this well)

## AEO / GEO / llms.txt

Discovery is no longer только Google. Answer engines (Perplexity, ChatGPT browse) and **llms.txt** files help models cite you accurately. I ship structured data + machine-readable profiles on every client site now.

## Takeaway

Treat LLMs as **orchestration layers**, not magic. The engineers who win in 2026 pair models with MCP, graphs, and boring reliability engineering.

## Production patterns

Treat observability, auth boundaries, and idempotent handlers as part of the feature—not stretch goals. Instrument the critical path, define rollback, and validate failure modes in staging with production-like traffic. Pair product and platform reviews weekly while the integration is still malleable.

## Pitfalls

Deferring security or accessibility review, relying on color-only status cues, and shipping WebView shortcuts for rich text are common sources of expensive rework. Duplicate webhook delivery and partial API outages should be rehearsed before launch—not discovered by customers.

## Authoritative references

Consult [LangGraph.js](https://langchain-ai.github.io/langgraphjs/), [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web), [web.dev](https://web.dev/), [Next.js documentation](https://nextjs.org/docs), [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/) alongside the official references block below. Cross-check guidance with your compliance, security, and SRE stakeholders before setting SLOs.

## Testing checklist

Exercise happy paths, auth expiry, retry storms, and degraded dependencies. Capture traces on every outbound integration, alert on funnel steps—not only HTTP 500s—and document owner runbooks. Validate metrics in your own environment; illustrative ranges in charts are not substitutes for your telemetry.

## Leadership takeaway

LLMs, MCP, and the Agentic Web in 2026 succeeds when teams align scope, measurable outcomes, and inclusive UX from sprint zero. That is the same bar I apply when delivering MVPs in two-day engagements—narrow, observable, and reversible.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while LLMs, MCP, and the Agentic Web in 2026 scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while LLMs, MCP, and the Agentic Web in 2026 scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while LLMs, MCP, and the Agentic Web in 2026 scales from pilot to full traffic.

## Metrics snapshot

![LLMs, MCP, and the Agentic Web in 2026 — key metrics](/images/blog/diagrams/llms-mcp-and-the-agentic-web-2026-metrics.png)

Illustrative ai KPI ranges observed on programs like “LLMs, MCP, and the Agentic Web in 2026” — validate against your own telemetry before setting SLOs. Methodology: production-like staging traces + weekly review with product and ops.

## Architecture flow

![LLMs, MCP, and the Agentic Web in 2026 — integration flow](/images/blog/diagrams/llms-mcp-and-the-agentic-web-2026-flow.png)

## Code sketches

```javascript
/* Integration sketch */
// LLMs, MCP, and the Agentic Web in 2026
export async function rolloutLlmsMcpAndTheAgenticWeb2026() {
  const checks = ["telemetry", "auth", "rollback"];
  return { ok: true, checks };
}
```

## Official references

- [LangGraph.js](https://langchain-ai.github.io/langgraphjs/)
- [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web)
- [web.dev](https://web.dev/)
- [Next.js documentation](https://nextjs.org/docs)
- [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/)

## Related on this site

- [Juiceit.ai](https://www.nitin-rachabathuni.com/project/juiceit)
- [Related engineering article](https://www.nitin-rachabathuni.com/blog/how-to-be-a-front-end-developer)
- [Implementation help](https://www.nitin-rachabathuni.com/contact)

## Related case study

[Juiceit.ai](https://www.nitin-rachabathuni.com/project/juiceit) — AI platform — document intelligence, agent workflows, enterprise automation.

_Article slug: `llms-mcp-and-the-agentic-web-2026` · Engineering notes by **Nitin Rachabathuni** — MVP in 2 days specialist._

How GPT-4o, Claude, Gemini, Ollama, and Model Context Protocol are reshaping how senior engineers build products — not just demos.

LLMs, MCP, and the Agentic Web in 2026

Cloud LLM bills add up. For **personal automation** and **sensitive workflows**, I run **Ollama** locally and orchestrate with **n8n** + **Python**.

## Architecture (Job Hunt Automation pattern)

```
n8n cron → Next.js API → Python ingest → Ollama tailor → Gmail PDF → Postgres
```

- **Discover** jobs via Playwright
- **Filter** in dashboard
- **Compose** cover letters + emails with local model
- **Track** applications and replies

## When local wins

- Secrets stay on your machine (encrypted git-crypt)
- Unlimited iterations during prompt tuning
- No per-token anxiety for batch jobs

## When cloud wins

- Highest reasoning quality for architecture decisions
- Multimodal (screenshots, PDFs) at scale
- SLA-backed APIs for customer-facing agents

## Hardware reality (Mac / Linux)

- 8–16GB RAM: 7B–8B quant models for drafting
- 32GB+: 14B models for better instruction following
- Always measure **time-to-first-token** vs cloud latency

## Takeaway

**Hybrid LLM strategy**: Ollama for volume and privacy; GPT/Claude for customer-facing agent peaks. Engineer the router — don't pick one religion.

## Why this matters

Why I run Ollama for job-hunt automation, resume tailoring, and client PoCs — and when to still use OpenAI or Claude. Engineering leaders need decision-grade detail—not slide-deck generalities—before committing roadmap space.

## Production patterns

Treat observability, auth boundaries, and idempotent handlers as part of the feature—not stretch goals. Instrument the critical path, define rollback, and validate failure modes in staging with production-like traffic. Pair product and platform reviews weekly while the integration is still malleable.

## Pitfalls

Deferring security or accessibility review, relying on color-only status cues, and shipping WebView shortcuts for rich text are common sources of expensive rework. Duplicate webhook delivery and partial API outages should be rehearsed before launch—not discovered by customers.

## Authoritative references

Consult [Next.js documentation](https://nextjs.org/docs), [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web), [web.dev](https://web.dev/), [Next.js documentation](https://nextjs.org/docs), [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/) alongside the official references block below. Cross-check guidance with your compliance, security, and SRE stakeholders before setting SLOs.

## Testing checklist

Exercise happy paths, auth expiry, retry storms, and degraded dependencies. Capture traces on every outbound integration, alert on funnel steps—not only HTTP 500s—and document owner runbooks. Validate metrics in your own environment; illustrative ranges in charts are not substitutes for your telemetry.

## Leadership takeaway

Local LLMs with Ollama succeeds when teams align scope, measurable outcomes, and inclusive UX from sprint zero. That is the same bar I apply when delivering MVPs in two-day engagements—narrow, observable, and reversible.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Local LLMs with Ollama scales from pilot to full traffic.

## Metrics snapshot

![Local LLMs with Ollama — Private Automation That Scales to Zero Cloud Cost — key metrics](/images/blog/diagrams/local-llms-ollama-private-automation-metrics.png)

Illustrative ai KPI ranges observed on programs like “Local LLMs with Ollama — Private Automation That Scal…” — validate against your own telemetry before setting SLOs. Methodology: production-like staging traces + weekly review with product and ops.

## Architecture flow

![Local LLMs with Ollama — Private Automation That Scales to Zero Cloud Cost — integration flow](/images/blog/diagrams/local-llms-ollama-private-automation-flow.png)

## Code sketches

```javascript
/* Integration sketch */
// Local LLMs with Ollama — Private Automation That Scal…
export async function rolloutLocalLlmsOllamaPrivateAutomation() {
  const checks = ["telemetry", "auth", "rollback"];
  return { ok: true, checks };
}
```

## Official references

- [Next.js documentation](https://nextjs.org/docs)
- [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web)
- [web.dev](https://web.dev/)
- [Next.js documentation](https://nextjs.org/docs)
- [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/)

## Related on this site

- [Related engineering article](https://www.nitin-rachabathuni.com/blog/how-to-be-a-front-end-developer)
- [Engineering blog](https://www.nitin-rachabathuni.com/blog)
- [Implementation help](https://www.nitin-rachabathuni.com/contact)

_Article slug: `local-llms-ollama-private-automation` · Engineering notes by **Nitin Rachabathuni** — MVP in 2 days specialist._

Why I run Ollama for job-hunt automation, resume tailoring, and client PoCs — and when to still use OpenAI or Claude.

Local LLMs with Ollama — Private Automation That Scales to Zero Cloud Cost

AI agents are moving from demos to production. With **LangGraph.js**, you can orchestrate multi-step reasoning loops where an LLM plans, acts, observes results, and iterates — similar to how a developer debugs code.

## Why LangGraph for agents

Unlike single-shot prompt chains, LangGraph models agent behavior as a **state machine**. Each node is a step (plan, execute, validate), and edges define transitions based on outcomes. This makes agents debuggable, testable, and safe to deploy.

## A practical pattern: code execution agents

In my [AiAgentRunJS](https://github.com/nitin-rachabathuni/AiAgentRunJS) project, the agent:

1. Receives a task in natural language
2. Generates JavaScript to solve it
3. Executes code in a sandboxed environment
4. Reads stdout/errors and retries if needed

This pattern works for data transforms, API glue code, and internal tooling.

## Safety first

Production agents need guardrails:

- **Sandbox execution** — never run arbitrary code on the main process
- **Token budgets** — cap LLM calls per request
- **Tool allowlists** — restrict which APIs the agent can call
- **Human-in-the-loop** — confirm destructive actions

## Combining with n8n

LangGraph handles reasoning; **n8n** handles scheduling, webhooks, and integrations. Together they form a powerful automation stack for teams that don't want to build everything from scratch.

## Takeaway

Start with a narrow, well-defined agent (e.g. "transform this CSV schema"). Add tools incrementally. Measure success by tasks completed without human intervention — not by how impressive the demo looks.

## Production patterns

Treat observability, auth boundaries, and idempotent handlers as part of the feature—not stretch goals. Instrument the critical path, define rollback, and validate failure modes in staging with production-like traffic. Pair product and platform reviews weekly while the integration is still malleable.

## Pitfalls

Deferring security or accessibility review, relying on color-only status cues, and shipping WebView shortcuts for rich text are common sources of expensive rework. Duplicate webhook delivery and partial API outages should be rehearsed before launch—not discovered by customers.

## Authoritative references

Consult [LangGraph.js](https://langchain-ai.github.io/langgraphjs/), [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web), [web.dev](https://web.dev/), [Next.js documentation](https://nextjs.org/docs), [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/) alongside the official references block below. Cross-check guidance with your compliance, security, and SRE stakeholders before setting SLOs.

## Testing checklist

Exercise happy paths, auth expiry, retry storms, and degraded dependencies. Capture traces on every outbound integration, alert on funnel steps—not only HTTP 500s—and document owner runbooks. Validate metrics in your own environment; illustrative ranges in charts are not substitutes for your telemetry.

## Leadership takeaway

Building AI Agents with LangGraph.js succeeds when teams align scope, measurable outcomes, and inclusive UX from sprint zero. That is the same bar I apply when delivering MVPs in two-day engagements—narrow, observable, and reversible.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

Document integration contracts, run weekly reviews with product and SRE partners, and keep rollback paths rehearsed while Building AI Agents with LangGraph.js scales from pilot to full traffic.

## Metrics snapshot

![Building AI Agents with LangGraph.js — key metrics](/images/blog/diagrams/building-ai-agents-with-langgraph-metrics.png)

Illustrative ai KPI ranges observed on programs like “Building AI Agents with LangGraph.js” — validate against your own telemetry before setting SLOs. Methodology: production-like staging traces + weekly review with product and ops.

## Architecture flow

![Building AI Agents with LangGraph.js — integration flow](/images/blog/diagrams/building-ai-agents-with-langgraph-flow.png)

## Code sketches

```javascript
/* Integration sketch */
// Building AI Agents with LangGraph.js
export async function rolloutBuildingAiAgentsWithLanggraph() {
  const checks = ["telemetry", "auth", "rollback"];
  return { ok: true, checks };
}
```

## Official references

- [LangGraph.js](https://langchain-ai.github.io/langgraphjs/)
- [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web)
- [web.dev](https://web.dev/)
- [Next.js documentation](https://nextjs.org/docs)
- [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/)

## Related on this site

- [Juiceit.ai](https://www.nitin-rachabathuni.com/project/juiceit)
- [Related engineering article](https://www.nitin-rachabathuni.com/blog/how-to-be-a-front-end-developer)
- [Implementation help](https://www.nitin-rachabathuni.com/contact)

## Related case study

[Juiceit.ai](https://www.nitin-rachabathuni.com/project/juiceit) — AI platform — document intelligence, agent workflows, enterprise automation.

_Article slug: `building-ai-agents-with-langgraph` · Engineering notes by **Nitin Rachabathuni** — MVP in 2 days specialist._

How to design tool-using AI agents that write and execute code safely in Node.js production environments.

AI articles

LLMs, MCP, and the Agentic Web in 2026

Local LLMs with Ollama — Private Automation That Scales to Zero Cloud Cost

Building AI Agents with LangGraph.js