263 Ultimate TypeScript Real-World AI Projects

263 blueprint-grade workflows, agents, and multi-agent systems — TypeScript-first. The Project catalog is documentation you can build from; only selected paths also have runnable reference code under reference-implementations/.

Most AI repos stop at call an API and hope it works. Plenty of content teaches SDK calls; far less shows how to ship systems that hold up in production. This repo goes further: real system design — not chatbot demos.

If you are trying to level up:

• Prompts → systems
• Demos → production

How This Repository Is Organized

This repository has two layers:

• Blueprint catalog — 263 AI system blueprints under projects/, each with README.md and architecture.md.
• Production reference layer — reusable TypeScript packages under packages/, runnable code under reference-implementations/, the benchmarks/ harness, and CI quality gates (.github/workflows/production-reference-ci.yml).

Most projects are blueprints only (documentation you implement in your own codebase). Selected catalog ideas become runnable reference implementations that share @repo/* packages and tests — not a promise that all 263 rows ship as code in this repo.

flowchart TD
    A[README Project Catalog] --> B[Blueprint Projects]
    A --> C[Learning Docs]
    A --> D[Top Projects]

    B --> B1[projects/domain/project/README.md]
    B --> B2[projects/domain/project/architecture.md]

    C --> C1[Learning Path]
    C --> C2[Production Patterns]
    C --> C3[Contribution Guides]

    D --> E[Reference Implementations]
    E --> E1[AI Cost Monitoring Engine]
    E --> E2[Future: Multi-Agent Incident Response]
    E --> E3[Future: Enterprise RAG Platform]

    E --> F[Shared Packages]
    F --> F1["@repo/core"]
    F --> F2["@repo/governance"]
    F --> F3["@repo/evals"]

    E --> G[Benchmarks]
    G --> G1[Methodology]
    G --> G2[Benchmark Suites]
    G --> G3[Local Results]

    E --> H[CI / Quality Gates]

Production Reference Architecture Layer

This repository remains catalog-first. The Project catalog (263 blueprint rows) is the main learning resource: every entry points at projects/<domain>/<slug>/ with README.md (problem, stack, evaluation, failure modes) and architecture.md (diagrams and engineering depth). Nothing here replaces that contract with a second registry.

Alongside the catalog, an additive production reference architecture layer helps you go from “what to build” to “how it can look in TypeScript” without pretending every blueprint is shipping code:

• Selected runnable references — a small, growing set of clone-and-run slices under reference-implementations/ that mirror specific catalog paths. They demonstrate ingestion, rollups, governance hooks, and similar patterns you can adapt; they are not a completeness matrix for all 263 ideas.
• Shared packages — reusable libraries under packages/ (@repo/core, @repo/governance, @repo/evals) for runtime and governance primitives. These are building blocks and documentation-backed patterns — not compliance certifications (see each package README).
• Benchmarks — a transparent harness in benchmarks/ with explicit methodology (benchmarks/methodology.md): local timings, environment metadata, and no implied SLAs or competitive “wins” without controlled reproduction.

Roadmap and boundaries: docs/PRODUCTION_REFERENCE_ARCHITECTURE_PLAN.md.

First flagship (runnable): reference-implementations/ai-cost-monitoring-engine — companion to the blueprint projects/devtools/ai-cost-monitoring-engine.

Blueprint Catalog

263 project ideas, each with README.md + architecture.md under projects/. The catalog tables below are the authoritative registry.

Reference Implementations

Selected runnable systems that exercise shared packages and show production-shaped wiring (observability seams, governance integration, honest limitations). They link back to catalog paths for context; they do not renumber or replace catalog rows.

Shared Packages

Reusable TypeScript modules (@repo/core, @repo/governance, @repo/evals) shared by reference apps and future flagships — narrow APIs, strict typing, tests where code exists. Prefer extending these over copy-pasting patterns into every new implementation.

CI and local checks (production layer)

GitHub Actions: .github/workflows/production-reference-ci.yml runs on push and pull_request to main: install pnpm, install dependencies, pnpm run typecheck, pnpm test, and a benchmark smoke (@repo/benchmarks cost-monitoring suite with mock-only data — no API keys, no external LLM calls).

Run tests locally (repository root):

pnpm install
pnpm run typecheck
pnpm test

Run benchmarks locally

• Shared harness (benchmarks/) — cost monitoring suite (writes timestamped artifacts under benchmarks/results/ unless gitignored):

cd benchmarks
pnpm suite:cost-monitoring
# optional: faster smoke
BENCHMARK_ITERATIONS=5 COST_MONITORING_EVENT_SCALE=20 pnpm suite:cost-monitoring

• Reference-local micro-benchmark (optional, in-package):

cd reference-implementations/ai-cost-monitoring-engine
pnpm benchmark

Interpret timings using benchmarks/methodology.md (local reference only).

Why this repo exists

After building and reviewing real AI products, one wall kept showing up: “We have prompts… now what?” Teams stall at prompt + API call while the product still needs:

• Orchestration — durable pipelines, handoffs, and control flow
• Decision-making — agents that choose under constraints, not just generate text
• Memory — what to retain, retrieve, and forget
• Failure handling — retries, fallbacks, guardrails, human-in-the-loop
• Cost vs latency tradeoffs — explicit budgets, not accidental bills

This collection bridges that gap with practical blueprints you can actually build: problems, architecture, TypeScript-friendly stacks, evaluation, failure modes, and scaling — systems thinking applied to AI.

What is inside

Summary counts match the Project catalog below. Each catalog entry is a blueprint: problem, architecture, TypeScript-oriented stack, evaluation, failure modes, and scaling — not a vague idea list.

How to explore (important)

This repo is catalog-driven (one registry in the README project catalog).

1. Start with the registry — the Project catalog lists every project once, with system type, complexity (L1–L5), capabilities, and path.
2. Browse by domain — open projects/ and pick a domain folder (for example projects/devtools/, projects/healthcare/, projects/fintech/, projects/enterprise-ai/, projects/security/, projects/travel/, and many more). Each project slug folder contains README.md and architecture.md.
3. Slice by system type or level — use the tables in the project catalog (columns System Type and Complexity). There are no separate by-system-type/ or by-complexity/ trees; the catalog is the filter.

Authoring rules for new catalog entries are described in CONTRIBUTING.md.

What you will learn

• System design for AI — when a durable workflow is enough, when an agent fits, when multiple agents collaborate, and how to structure decision loops safely.
• Production thinking — cost, latency, observability, guardrails, human-in-the-loop, and regression-style evaluation.
• Real tradeoffs — accuracy vs cost, autonomy vs control, reasoning depth vs time-to-answer.

Example projects (high signal)

Concrete paths for all of these are in the Project catalog.

Suggested path if you are new

System Types at a Glance

flowchart LR
    W[Workflow] --> W1[Deterministic Steps]
    W --> W2[Predictable Cost]
    W --> W3[High Reliability]

    A[Agent] --> A1[Reasoning]
    A --> A2[Tool Usage]
    A --> A3[Dynamic Decisions]

    M[Multi-Agent] --> M1[Specialized Roles]
    M --> M2[Coordination]
    M --> M3[Complex Workflows]

    U[Agentic UI] --> U1[User + AI Collaboration]
    U --> U2[Interactive State]
    U --> U3[Real-Time Suggestions]

Workflows fit repeatable processes with clear steps. Agents fit when decisions depend on context, tools, and guardrails. Multi-agent fits when several specialized roles must coordinate. Agentic UI fits when the user and AI collaborate inside the product experience (see blueprint batch under projects/agentic-ui/).

Complexity levels

Repository layout

README.md                 # Narrative + full project catalog (this file)
CONTRIBUTING.md           # How to propose or extend catalog entries
package.json              # pnpm workspace root (typecheck / test / lint placeholder)
pnpm-workspace.yaml       # Workspace packages under packages/*
tsconfig.base.json        # Shared strict TypeScript defaults
scripts/enrich_project_docs.py   # Adds stack + architecture layers (idempotent)
scripts/apply_agentic_ui_projects.py + scripts/agentic_ui_projects.json  # Regenerate AG-UI batch (dev)
packages/
  core/                   # @repo/core — runtime primitives (see package README)
  governance/             # @repo/governance — governance primitives
  evals/                  # @repo/evals — evaluation schemas / harness stubs
reference-implementations/  # Runnable flagships (e.g. ai-cost-monitoring-engine); see docs plan
benchmarks/               # @repo/benchmarks harness + suites (see benchmarks/README.md)
docs/
  PRODUCTION_REFERENCE_ARCHITECTURE_PLAN.md  # How the monorepo evolves with the catalog
  production-patterns/    # Cross-cutting production notes (scaffold)
  governance/             # Governance patterns (scaffold)
  benchmarking/           # Benchmark methodology (scaffold)
projects/
  <domain>/               # e.g. devtools, travel, enterprise-ai
    <project-slug>/
      README.md           # Full brief
      architecture.md     # Diagrams and engineering detail

Tech stack (TypeScript-first)

Typical stacks referenced across briefs include Node.js, Next.js, OpenAI / Anthropic, LangChain.js, Vercel AI SDK, Zod, vector stores (e.g. Pinecone, Supabase), and observability (LangSmith, Helicone, and similar). Each project’s README.md narrows this to what fits that system.

Project catalog

This section is the authoritative project registry: purpose, summary counts, every domain table, deduplication notes, and contribution reminders. PROJECT_INDEX.md is a short pointer file for stable links and local search.

🔍 Purpose

This Project catalog section is the single registry for catalog projects in this repository.

• Avoid duplication: Before starting or documenting a new system, scan the tables below to confirm the idea is not already covered.
• Balance the catalog: Use it to spot gaps across domains and system types (workflow vs agent vs multi-agent), so the collection stays useful rather than repetitive.
• Navigate quickly: Each row points to a folder containing README.md (full brief) and architecture.md (diagrams and engineering detail).

📊 Summary

How rows are counted: Each project has one primary row in exactly one domain table. “Workflow / workflow-first” includes systems where a durable workflow is the spine (including hybrid Workflow + Agent or Workflow → Agent designs). Agentic UI (AG-UI) marks blueprints where CopilotKit-style UI↔agent state and co-driven workflows are the spine (not a passive chat wrapper). “Level 5” counts projects whose brief targets Level 5 complexity.

🚀 Projects

Paths are repository-relative. Each path contains README.md and architecture.md.

✈️ Travel

🍽️ Lifestyle

🧑‍💻 DevTools

🧑‍💻 DevTools AI

🤖 Agentic UI

Note: AI Live Log Debugging Copilot UI is the AG-UI + live log stream blueprint; projects/devtools/ai-debugging-assistant remains the general code/debug agent pattern. AI Travel Planning Workspace is the collaborative itinerary board; projects/travel/ai-travel-planner remains the multi-agent supplier orchestration reference—compose them if you want both.

🧩 Platform

🎨 Frontend

⚙️ Workflows

🧭 Productivity

🎧 Support

🛠️ DevOps

💳 Fintech

🏥 Healthcare

🧾 Finance

⚖️ Legal

⚖️ Legal AI

💼 Sales

🎓 Education

🧑‍🤝‍🧑 Personal AI

👨‍👩‍👧 Family

🔐 Security

🌐 Web3

🏭 IoT

🎮 Gaming

🎤 Voice

🎙️ AI Interface

📣 Marketing

📰 Media

📈 Analytics

🏢 Enterprise

🏢 Enterprise AI

🛒 E-commerce

🚚 Logistics

🏠 Real Estate

👥 HR

🧠 AI Core

🔌 AI Infra

Note: A separately named “MCP Tool Registry & Discovery System” is intentionally not a second catalog row—it overlaps the existing MCP Tool Registry System (registry + discovery + permissions). Extend that brief if you need more detail.

Note: The candidate “MCP Server Hub & Registry Platform” is treated as the same catalog surface area as MCP Tool Registry System—use that project and extend it rather than adding a duplicate row.

🏭 Industrial AI

🌾 Agri AI

⚡ Energy AI

🧪 Research AI

🎬 Creator AI

🏛️ Gov AI

🛡️ Security AI

Note: AI Phishing Detection System (projects/security/ai-phishing-detection-system) focuses on classification at the mailbox/ingress edge; Automated Phishing Takedown Agent focuses on post-detection abuse response (evidence bundles, provider workflows).

Note: Zero Trust Behavioral Authenticator focuses on session/access trust signals; Continuous Insider Threat Detection Agent focuses on insider-risk case building (cross-system UEBA-style correlation to SIEM).

🧘 Health AI

🚢 Logistics AI

🌍 Climate AI

🛰️ Geo AI

🌱 Sustainability

Note: “AI NPC Dialogue Orchestrator” is not a separate catalog row—it overlaps AI NPC Behavior Engine (projects/gaming/ai-npc-behavior-engine); extend that brief for memory-heavy dialogue orchestration. “Urban Traffic Flow Multi-Agent System” overlaps Multi-Agent Smart City Traffic System (projects/iot/multi-agent-smart-city-traffic-system).

🧭 Contribution Note

Before adding a new project:

1. Check the tables below and confirm the path/name is not already taken.
2. Avoid duplication—extend an existing README.md if the scope overlaps.
3. Add new value—prefer a distinct problem, integration surface, or production lesson.

Naming: keep titles practical and specific.

Ideas: favor real-world constraints—integrations, evaluation, cost, safety—over generic assistants with no clear architecture.

When you add a project:

• Create projects/<domain>/<project-slug>/README.md under the right domain folder in projects/, mirroring the headings and depth of sibling entries (for example projects/travel/ai-travel-planner/README.md).
• Add architecture.md with the sections used elsewhere in this repo (overview, ASCII diagram, components, data flow, agent interaction, scaling, failure handling, observability).
• Update this catalog section (summary counts + the correct domain table) in the same change.

Contributing

This project values real systems, clear architecture, and production thinking — not generic assistant ideas. See CONTRIBUTING.md for the full process; in short, scan the Project catalog for duplicates, mirror the structure of nearby projects under projects/, and ship README.md + architecture.md plus a new row in the catalog tables.

Who this is for

Senior and staff engineers, AI engineers, and anyone who wants to move from “I shipped a chatbot” to “I designed a production AI system.”

Vision

To be a practical, TypeScript-first reference for real-world AI system design — workflows, agents, and multi-agent systems — with honesty about tradeoffs and failure modes.

If this repo helps you, a star on GitHub helps others find it.