NestJS + LangChain vs HazelJS

TL;DR

• NestJS + LangChain is the default “production AI backend” recipe for many TypeScript teams.
• It works — and it creates two frameworks, two config stories, and a lot of glue between HTTP and AI.
• HazelJS Agent OS: DNA packages, crash-safe HITL, Skillgate, and local apply — one DI app, not Nest + LangChain glue.
• Keep Nest + LangChain if you already invested heavily and AI is a thin layer.
• Switch (or start new) on HazelJS when durable agents are the product — clone Meridian.

Who this is for

Teams that:

• Run NestJS APIs and added LangChain for RAG/agents
• Feel pain from dual paradigms (Nest providers vs LangChain runnables)
• Want auth, caching, observability, and agents under one roof

Not ideal if:

• You only need a few LLM calls in Nest controllers (raw OpenAI SDK may be enough)
• You depend on LangChain ecosystem plugins HazelJS does not mirror yet
• You are Python-first (LangChain’s gravity is stronger there)

The glue-code problem

A typical Nest + LangChain setup looks like:

NestJS module
  └─ Controller / Guard / Pipe
       └─ Service
            └─ LangChain chain / agent / retriever
                 └─ Vector store, embeddings, tools, memory

Every new AI feature means bridging:

• Nest DI ↔ LangChain constructors
• Nest config ↔ LangChain env/secrets
• Nest logging/OTel ↔ LangSmith or custom LLM traces
• Nest auth context ↔ tool execution identity

HazelJS collapses that bridge: Agent OS runs in the same graph as your HTTP layer. HCEL chains are optional for brownfield orchestration — not the wedge.

Side-by-side

Code: glue vs native

Nest service wrapping LangChain (illustrative glue):

// Nest provider manually constructs LangChain pieces
@Injectable()
export class ChatService {
  private chain: any;

  constructor(private config: ConfigService) {
    const model = new ChatOpenAI({ apiKey: this.config.get('OPENAI_API_KEY') });
    const retriever = /* wire vector store */;
    this.chain = RunnableSequence.from([
      /* prompt */,
      retriever,
      model,
    ]);
  }

  async ask(input: string) {
    return this.chain.invoke({ input });
  }
}

HazelJS Agent OS execute in the same DI world:

await runtime.execute('support-desk', input, {
  loop: { maxIterations: 4, successScore: 90 },
  contract: { fallbackAgent: 'safe-desk' },
  recovery: { maxRetries: 2, fallbackAgent: 'safe-desk' },
});

Also available — HCEL for brownfield chains only:

import { Injectable } from '@hazeljs/core';
import { AIService } from '@hazeljs/ai';

@Injectable()
export class ChatService {
  constructor(private ai: AIService) {}

  async ask(input: string) {
    return this.ai.hazel
      .prompt('Answer using docs: {{input}}')
      .rag('engineering-docs')
      .agent('support-specialist')
      .execute(input);
  }
}

Support agent with real @Tool handlers (DNA lists names only):

import { Agent, Tool } from '@hazeljs/agent';

@Agent({
  name: 'support-desk',
  enableMemory: true,
  systemPrompt: 'Resolve tickets with tools when needed.',
})
export class SupportDeskAgent {
  @Tool({
    description: 'Create a ticket',
    parameters: [{ name: 'title', type: 'string', required: true }],
  })
  async createTicket(input: { title: string }) {
    return { id: 'T-100', title: input.title };
  }
}

Decision guide

When NestJS + LangChain is better

• Your org standardized on LangSmith / LangGraph and training is done
• You need a LangChain integration HazelJS does not ship yet
• Political cost of introducing another framework exceeds glue-code cost

HazelJS is the better default when durable agents in your TypeScript backend matter more than LangChain ecosystem breadth.

Related comparisons

• HazelJS vs NestJS — framework-only view
• HazelJS vs LangChain — AI library view
• What is an Agent OS? — category definition
• Agent OS Gamma — durable AgentRun vs in-memory graphs
• Skillgate — OpenAPI → governed agent skills
• Meridian — flagship teaching app

Next steps

1. Clone Meridian
2. Agent OS guide
3. Skillgate guide
4. Docs: Agent package
5. GitHub