OpenWiki vs QuotyAI: Two LangChain DeepAgents Projects, Two Architectures

OpenWiki, built by LangChain AI, is an open-source CLI that reads a codebase and writes markdown documentation for coding agents. QuotyAI is a sales AI platform that reads business rules and writes executable TypeScript pricing functions, JSON schemas, and validation logic. Both use the same createDeepAgent function, the same LangChain orchestration, and TypeScript.

The shared foundation is real. Both projects call the same factory function, use the same subagent delegation pattern, and checkpoint conversations with LangGraph. The divergence happens in what the agent produces and what happens to that output after generation.

OpenWiki writes markdown files that sit in a repository. QuotyAI writes TypeScript functions that run in a sandboxed VM on every incoming customer message. That single difference — reference material vs production code — cascades into different agent architectures, different safety models, and different business outcomes.

---

How OpenWiki generates agent documentation with LangChain

OpenWiki solves a specific problem: when you point Claude Code or Cursor at a new repository, the agent knows nothing about the architecture, conventions, or domain model. OpenWiki reads the codebase, synthesizes understanding, and writes structured markdown into an openwiki/ directory:

openwiki/
  quickstart.md              # Entrypoint with links to all sections
  .last-update.json          # Git head, timestamp, model metadata
  architecture/
    overview.md
    data-flow.md
  api/
    endpoints.md
    authentication.md
  domain/
    entities.md
    business-rules.md

A GitHub Action runs openwiki --update daily. The agent diffs git, identifies which documentation pages are affected by recent source changes, and rewrites only those pages. The AGENTS.md and CLAUDE.md files in the repository root point coding agents to the wiki as their entrypoint.

The CLI runs locally, stores checkpoints in SQLite at ~/.openwiki/openwiki.sqlite, and supports five LLM providers (OpenAI, Anthropic, OpenRouter, Fireworks, Baseten). It’s MIT-licensed and free.

How QuotyAI generates executable TypeScript with DeepAgents

QuotyAI solves a different problem: when an AI agent handles pricing for a business, getting the answer wrong means lost revenue. A spa owner types “our deep tissue massage costs 90 for 60 minutes, 120 for 90 minutes, and we offer a 10% discount for members.” The platform generates a quoteOrder() function that returns $108 for a 90-minute member booking. Every time.

The output lives in structured skill directories stored in MongoDB with versioned generations:

/sales-assistant/skills/
  offerings/
    skill.md                 # YAML frontmatter + instructions
    reference.md             # Structured product catalog
    schema/
      schema.json            # JSON Schema (source of truth)
      schema.ts              # TypeScript types (auto-derived, readonly)
  pricing-rules/
    skill.md
    reference.md             # Pricing rules in structured markdown
    scripts/
      function.js            # quoteOrder(order) -> QuoteResult
  scheduling/
    skill.md
    reference.md
    scripts/
      function.js            # transformToCheckAvailability(order)

Eight locked skills form the core: offerings schema, order schema, pricing formula, scheduling function, validation function, router, callback, and system prompt. Each has a defined role in the sales conversation pipeline.

The platform runs as multi-tenant SaaS on GCP, charges $50/month per business, and executes generated code in a sandboxed Node.js VM with a 5-second timeout and no access to require, import, fetch, process, filesystem, or network.

---

Both projects call createDeepAgent — here’s how the code differs

Both projects call createDeepAgent from the deepagents npm package. The function provides built-in filesystem tools (ls, read_file, write_file, edit_file, glob, grep), sub-agent delegation via the task tool, planning via write_todos, checkpointing, and streaming with subgraph support.

OpenWiki passes an empty tools: [] array and relies entirely on the defaults:

import { createDeepAgent, LocalShellBackend } from 'deepagents';
import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';

const checkpointer = SqliteSaver.fromConnString(checkpointPath);

const agent = createDeepAgent({
  model,
  tools: [],
  checkpointer,
  backend: new LocalShellBackend({
    maxOutputBytes: 100_000,
    rootDir: cwd,
    timeout: 120,
    virtualMode: true,
  }),
  systemPrompt: createSystemPrompt(command),
});

The system prompt runs ~800 lines. It covers documentation quality rules, git discipline, subagent delegation constraints, and mode-specific behavior for init, update, and chat commands. No custom tools. No subagent definitions in code. The prompt is the product.

QuotyAI passes custom file tools, 11 subagents, HITL interrupts, and a composite backend that maps /memories/ to a LangGraph store and /patterns/ to the same skill file backend:

import { createDeepAgent, CompositeBackend, StoreBackend } from 'deepagents';
import { initChatModel } from 'langchain/chat_models/universal';

const model = await initChatModel(p.llmConfig.model, {
  modelProvider: p.llmConfig.provider,
  temperature: 0.1,
});

const backend = new CompositeBackend(p.backend, {
  '/memories/': new StoreBackend({ namespace: memoryNamespace }),
  '/patterns/': p.backend,
});

const agent = createDeepAgent({
  model,
  backend,
  checkpointer: p.checkpointer,
  store: p.store,
  systemPrompt: buildOrchestratorPrompt({ ... }),
  memory: ['/memories/AGENTS.md'],
  interruptOn: p.mode === DeepAgentRunMode.APPROVAL_REQUIRED
    ? { eval: { allowedDecisions: [AllowedDecision.APPROVE, AllowedDecision.REJECT] } }
    : undefined,
  middleware: [createCodeInterpreterMiddleware({ ptc: ['read_file', 'ls', 'grep', 'glob'] })],
  subagents: [
    knownPatternEditor,
    generalCascadeEditor,
    ...codeGenSubagents,
  ],
});

The checkpoint lives in MongoDB, not SQLite. The backend is a virtual filesystem backed by MongoDB object storage with generation-based versioning. The orchestrator never calls write_skill_file or edit_skill_file directly — all file modifications go through editing subagents dispatched via task().

---

OpenWiki’s single agent vs QuotyAI’s 11-subagent orchestrator

OpenWiki’s agent is a single LLM that reads code, plans documentation structure, and writes files. It can spawn subagents via task() to parallelize research, but the system prompt enforces a constraint: “Subagents must ONLY inspect and summarize — they must NOT create, edit, delete, or move files.” Subagents return findings. The main agent writes the docs.

QuotyAI’s agent is an orchestrator that classifies intent before acting. A lightweight LLM call with structured output classifies the user message as query (read-only) or update (modify files), and if update, identifies which known pattern matches: add-offering, remove-offering, update-price, add-user-skill, or null for arbitrary changes.

For known patterns, the orchestrator dispatches a known-pattern-editor subagent that reads the pattern’s SKILL.md from /patterns/{pattern-name}/SKILL.md and follows step-by-step instructions. For arbitrary changes, it dispatches a general-cascade-editor that reasons about what to change on its own.

Both editing subagents dispatch code generation subagents — 9 specialized generators, each a separate LLM call with its own system prompt and responseFormat validation:

Subagent	Reads	Writes
offerings-schema-generator	/offerings/reference.md	/offerings/schema/schema.json
order-schema-generator	/order-schema/reference.md + offerings schema	/order-schema/schema/schema.json
pricing-formula-generator	/pricing-rules/reference.md + offerings types + order types	/pricing-rules/scripts/function.js
scheduling-function-generator	/scheduling/reference.md + offerings + order types	/scheduling/scripts/function.js
validation-function-generator	/validation/reference.md + offerings + order types	/validation/scripts/function.js
router-function-generator	skill.md + reference.md + order types + routeActions.json	skill’s scripts/function.js
callback-function-generator	skill.md + reference.md + order types	skill’s scripts/function.js
condition-function-generator	skill.md + order types	skill’s scripts/condition.js
instruction-tool-generator	skill.md + reference.md + order types	skill’s scripts/function.js + tools/tool.json

Every write_skill_file and edit_skill_file call from an editing subagent triggers a HITL interrupt. The frontend IDE surfaces the proposed change with three buttons: Approve, Edit, Reject. The agent pauses until the user decides.

---

Skill dependency cascades in QuotyAI’s DeepAgents architecture

Locked skills in QuotyAI form a directed acyclic graph. When one changes, downstream skills must regenerate:

offerings_schema ──────> order_schema ──────> pricing_formula
                                        ├───> scheduling_function
                                        └───> validation_function

router         (independent)
callback       (independent)
system_prompt  (independent)

The orchestrator dispatches code generation subagents in topological order. offerings-schema-generator runs first, then order-schema-generator. After that, pricing-formula-generator, scheduling-function-generator, and validation-function-generator run in parallel — they depend on order_schema but not on each other.

OpenWiki has no equivalent pattern. When the codebase changes, the agent diffs git, identifies affected pages, and rewrites them. Markdown pages don’t depend on each other the way executable schemas and functions do. An offerings schema change that doesn’t cascade to the pricing function produces inconsistent prices. A stale architecture doc just produces a confused developer.

---

Runtime execution: markdown files vs sandboxed TypeScript

OpenWiki’s output never executes. Markdown files sit in the repository. Coding agents read them as context. There’s no sandbox, no execution environment, no validation beyond “does the file exist.”

QuotyAI’s output runs on every incoming sales conversation. The pipeline loads skills from MongoDB, executes router functions to decide how to handle the message, calls the LLM if needed, and runs callback functions after the LLM responds. The execution environment is a vm.createContext sandbox with a strict allowlist:

• Allowed: Date, Math, Array, Object, String, Number, Boolean, RegExp, JSON, Error, TypeError, ReferenceError, RangeError, parseInt, parseFloat, isNaN, isFinite
• Blocked: require, import, eval, fetch, process, fs, net, setTimeout, setInterval
• Timeout: 5 seconds. Infinite loops in AI-generated code happen more often than you’d expect.

When a customer asks “how much is a 90-minute deep tissue massage for a member?”, the pipeline:

1. Loads the pricing-rules skill’s scripts/function.js from MongoDB
2. Loads the offerings skill’s schema/schema.ts for type definitions
3. Calls quoteOrder({ items: [{ service: "deep-tissue", duration: 90, member: true }] })
4. Gets back { total: 108, pricingCalculationBacktrace: { ... } } in 24ms
5. Returns the price with a full audit trail of how it was calculated

A stale OpenWiki page means a confused coding agent. A buggy QuotyAI function means an overcharged customer.

---

Error handling: git revert vs HITL approval interrupts

OpenWiki is designed for developer workflows where git is the safety net. The agent writes to openwiki/, you review the diff in a PR, and you merge or reject. The agent retries on 5xx errors from OpenRouter with automatic model fallback — the primary model plus GPT-5.4-mini and Claude Sonnet 5 are sent as fallbacks via OpenRouter’s route: "fallback" feature. If the agent writes a bad doc page, git revert fixes it.

QuotyAI is designed for business owners where the output affects revenue. Every file change goes through a HITL interrupt — the user sees exactly what will be written, can edit it in-place, or rejects it entirely. The codebase uses generation-based versioning with atomic compare-and-swap pointer swaps. If a generated function produces wrong results, the user can roll back to a previous generation without touching the live environment.

The error cost differs: a confusing doc page wastes a developer’s time. A wrong price calculation costs money.

---

Business impact: developer time vs revenue accuracy

The methodology difference changes who uses the product and what errors cost:

	OpenWiki	QuotyAI
Users	Developers, coding agents	Small businesses, solo entrepreneurs
Error cost	Confused developer	Overcharged customer
Update trigger	Daily (GitHub Action)	On-demand (user triggers)
Output verification	Human reads diff	HITL approves each file + sandbox validates generated code
Scaling model	More repos = more docs	More businesses = more revenue ($50/mo each)
Cost	Free (MIT)	$50/month

OpenWiki saves developer time. A coding agent with good docs writes better code, faster — fewer bugs, faster onboarding, less time explaining the codebase to new team members.

QuotyAI saves business owner money. A sales agent with deterministic pricing never hallucinates a price, never gives an unauthorized discount, and never double-books an appointment. Accurate pricing means no revenue leakage.

---

When to use OpenWiki vs QuotyAI for agent workflows

The choice depends on what your agent needs to do with the knowledge it generates.

OpenWiki fits when the agent needs context. Point Claude Code at a repository with no docs (or stale docs), run openwiki --init, and the coding agent has architecture notes, API docs, and domain concepts within minutes. The GitHub Action keeps them current. The output is reference material — it informs the agent’s decisions but doesn’t execute.

QuotyAI fits when the agent needs to run code. A spa owner describes pricing rules in natural language, and the platform generates a deterministic quoteOrder() function that executes in a sandboxed VM on every booking inquiry. The output is production code — it runs, calculates, and returns results with audit trails.

Neither product is a RAG pipeline. Neither replaces a simple chatbot. OpenWiki doesn’t generate executable code. QuotyAI doesn’t document codebases. They share a framework because the framework is general-purpose. The output format determines the architecture.

---

Tech stack: Node.js + SQLite vs Bun + MongoDB

Layer	OpenWiki	QuotyAI
Agent framework	deepagents ^1.10.5	deepagents (same package)
Orchestration	LangChain + LangGraph	LangChain + LangGraph
Language	TypeScript	TypeScript
Runtime	Node.js	Bun
HTTP framework	None (CLI only)	Hono
WebSocket	None	Socket.IO
Database	None (filesystem)	MongoDB
Checkpoint	SQLite	MongoDB
Streaming	LangGraph stream protocol	SSE via Hono + LangChain Agent Protocol
Tracing	Optional LangSmith	OpenTelemetry + LogTape
Frontend	React + Ink (terminal UI)	Angular 21
Voice	None	LiveKit + Deepgram
LLM providers	OpenAI, Anthropic, OpenRouter, Fireworks, Baseten	OpenAI, Anthropic, Google Gemini (BYOK)
Package manager	pnpm	pnpm (Nx monorepo)

---

Related reading

• Hono + Bun for AI Platforms: 6 Production Patterns Worth Stealing — the backend stack behind QuotyAI’s skill builder
• Open Knowledge Format (OKF) vs Agent Skills — why deterministic execution beats static knowledge files
• Determinism as Infrastructure — why AI platforms need deterministic execution
• Why I Picked Bun and Hono — the original decision breakdown for QuotyAI’s stack

---

Frequently Asked Questions

What is the difference between OpenWiki and QuotyAI? OpenWiki is an open-source CLI that generates and maintains markdown documentation for codebases using DeepAgents + LangChain. QuotyAI is a SaaS platform that uses the same DeepAgents + LangChain stack to build executable agent skills — generated TypeScript functions, JSON schemas, and structured reference data that run in sandboxed VMs.

Can OpenWiki and QuotyAI use the same LLM providers? Yes. Both support OpenAI, Anthropic, and OpenRouter. OpenWiki also supports Fireworks and Baseten. QuotyAI supports Google Gemini via BYOK. Both use LangChain’s initChatModel abstraction, so adding a new provider is a one-line change.

Why does QuotyAI need 9 code generation subagents when OpenWiki uses zero custom tools? OpenWiki generates markdown documentation — a single content type written by the orchestrator directly. QuotyAI generates executable code, JSON schemas, and structured data across 8 locked skills with dependency cascades. Each code type (pricing formula, scheduling function, validation logic) requires a specialized subagent with domain-specific prompt engineering and output validation.

Is DeepAgents only for documentation tools? No. DeepAgents provides composable primitives — createDeepAgent, SubAgent, Backend, checkpointing, tool registration — that work for any agent workflow. OpenWiki uses it for documentation generation. QuotyAI uses it for deterministic business logic generation with HITL interrupts, dependency cascades, and sandboxed execution. The framework is general-purpose; the methodology is what makes the product.

What is a dependency cascade in QuotyAI’s skill builder? When a locked skill changes (e.g., offerings schema), all downstream skills must regenerate. The cascade follows a DAG: offerings_schema -> order_schema -> pricing_formula + scheduling_function + validation_function. The orchestrator dispatches code generation subagents in topological order, parallelizing independent branches.

---

Tags: deepagents langchain openwiki quotyai ai-agents deterministic-ai typescript agent-skills