{ "type": "new-runtime-knowledge-index", "version": 1, "generated_at": "2026-07-23", "counts": { "tracks": 7, "guides": 34, "sections": 246, "cards": 1055 }, "routes": { "html": "https://newruntime.com/learn/", "json": "https://newruntime.com/learn.json" }, "tracks": [ { "slug": "llm-foundations", "title": "LLM Foundations", "description": "Build a mechanical model of tokens, neural networks, generation, prompts, and inference.", "routes": { "html": "https://newruntime.com/learn/tracks/llm-foundations/" }, "guides": [ { "volume": 7, "slug": "neuron-to-llm-reference", "title": "From a Neuron to an LLM", "description": "The route from linear regression to transformer: classical ML models and their limit, biological neuron and perceptron, deep networks and representations, recurrence and its problems, attention as a breakthrough, transformer as architecture and LLM as a result of scale.", "section_count": 8, "card_count": 23, "routes": { "html": "https://newruntime.com/learn/neuron-to-llm-reference/", "json": "https://newruntime.com/learn/neuron-to-llm-reference.json" } }, { "volume": 15, "slug": "llm-simply-explained", "title": "LLMs in Plain English", "description": "Not the history of architectures or GPU micro-optimizations, but practical mechanics without academic fog: how text is cut into tokens, how transformer blocks recalculate the meaning, how the encoder and decoder differ, how the model learns and why it responds one token at a time.", "section_count": 7, "card_count": 23, "routes": { "html": "https://newruntime.com/learn/llm-simply-explained/", "json": "https://newruntime.com/learn/llm-simply-explained.json" } }, { "volume": 5, "slug": "llm-internals-reference", "title": "LLM Internals: From Token to Logit to Answer", "description": "The full path from the input request to the next token: tokenization, embeddings, positional encoding, self-attention, MLP, normalization, KV-cache, logits, softmax and sampling parameters - parsed atomically.", "section_count": 7, "card_count": 28, "routes": { "html": "https://newruntime.com/learn/llm-internals-reference/", "json": "https://newruntime.com/learn/llm-internals-reference.json" } }, { "volume": 14, "slug": "llm-internals-kvcache-generation", "title": "LLM Internals: KV Cache & Generation", "description": "An in-depth analysis of the mechanics of inference: how exactly KV-cache works and why O(n²) without it, prefill vs decode phases, GPU memory arithmetic, GQA/MQA/PagedAttention, prompt caching at the API level (Anthropic + OpenAI), sampling from logits to token, speculative decoding, and the main case - “mother washed the frame” through LLM step by step.", "section_count": 8, "card_count": 24, "routes": { "html": "https://newruntime.com/learn/llm-internals-kvcache-generation/", "json": "https://newruntime.com/learn/llm-internals-kvcache-generation.json" } }, { "volume": 23, "slug": "prompt-dialog-mode-reference", "title": "What a Prompt Is and Why a Question Becomes an Answer", "description": "The main paradox of LLM is this: if the model is just predicting the next token, why does it answer the question meaningfully, and not just continue our text? This volume analyzes the prompt as the model's actual input, chat mode as a special data format, instruction tuning as a shift in behavior towards the “assistant”, and the connection of prompt with the model weights.", "section_count": 7, "card_count": 34, "routes": { "html": "https://newruntime.com/learn/prompt-dialog-mode-reference/", "json": "https://newruntime.com/learn/prompt-dialog-mode-reference.json" } } ] }, { "slug": "prompting-and-adaptation", "title": "Prompting & Adaptation", "description": "Move from hand-written instructions to context systems, fine-tuning, and programmatic prompt optimization.", "routes": { "html": "https://newruntime.com/learn/tracks/prompting-and-adaptation/" }, "guides": [ { "volume": 4, "slug": "llm-finetuning", "title": "Fine-Tuning Strategies", "description": "When to use fine-tuning, and when is RAG or prompting enough? LoRA, QLoRA, SFT, DPO, RLHF, distillation - broken down into focused cards. How to prepare data, how to evaluate the result, how not to waste the GPU.", "section_count": 8, "card_count": 27, "routes": { "html": "https://newruntime.com/learn/llm-finetuning/", "json": "https://newruntime.com/learn/llm-finetuning.json" } }, { "volume": 28, "slug": "context-engineering-prompt-caching", "title": "Context Engineering & Prompt Caching", "description": "This volume is not about the “magical prompt”, but about the engineering layer around it: from what blocks the context is collected, how the state lives between moves, what exactly is cached, when compaction is needed, how not to drown in tool outputs and what to measure in production. The idea is simple: the quality of an LLM system is often determined not by the model per se, but by the context you give it and how you manage its life cycle.", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/context-engineering-prompt-caching/", "json": "https://newruntime.com/learn/context-engineering-prompt-caching.json" } }, { "volume": 34, "slug": "dspy-gepa-reference", "title": "DSPy & GEPA: Implementation Cookbook", "description": "A big volume about how to really build systems on DSPy: all the key abstractions from official documentation, a built-in module map, data design and metrics, the choice of an optimizer, deep dive by GEPA and step-by-step rollout plans from the first baseline to production.", "section_count": 8, "card_count": 41, "routes": { "html": "https://newruntime.com/learn/dspy-gepa-reference/", "json": "https://newruntime.com/learn/dspy-gepa-reference.json" } } ] }, { "slug": "retrieval-and-rag", "title": "Retrieval & RAG", "description": "Understand vector search, enrichment, runtime branching, and production RAG implementation.", "routes": { "html": "https://newruntime.com/learn/tracks/retrieval-and-rag/" }, "guides": [ { "volume": 9, "slug": "rag-vector-search-reference", "title": "RAG & Vector Search", "description": "Full route: why words cannot be compared directly → Bag of Words → TF-IDF → Word2Vec → contextual embeddings → cosine distance → how exactly the chunk “matches” with the query → HNSW → hybrid search → the full RAG pipeline parsed down to the byte.", "section_count": 7, "card_count": 24, "routes": { "html": "https://newruntime.com/learn/rag-vector-search-reference/", "json": "https://newruntime.com/learn/rag-vector-search-reference.json" } }, { "volume": 13, "slug": "advanced-rag-context-enrichment", "title": "Advanced RAG: Context & Enrichment", "description": "Deep analysis of the context enrichment layer in RAG: RAG vs Fine-tuning - when to choose what, advanced chunking strategies, query augmentation and decomposition, four patterns of context degradation, compression and hygiene, memory layers, incremental index updating, citations & grounding, prompt injection through documents.", "section_count": 7, "card_count": 24, "routes": { "html": "https://newruntime.com/learn/advanced-rag-context-enrichment/", "json": "https://newruntime.com/learn/advanced-rag-context-enrichment.json" } }, { "volume": 18, "slug": "rag-runtime-reference", "title": "RAG Runtime: From Cosine Similarity to the Final Answer", "description": "Not “what is RAG” in general terms, but what actually happens at the code and object level: what data structures are created during indexing, what exactly the vector store returns, who reacts to `score`, what if/else branches are triggered after retrieval, how rerank, packing, refusal, citations and debugging are done. This volume is about RAG as an executable program.", "section_count": 7, "card_count": 33, "routes": { "html": "https://newruntime.com/learn/rag-runtime-reference/", "json": "https://newruntime.com/learn/rag-runtime-reference.json" } }, { "volume": 19, "slug": "production-rag-python-reference", "title": "Production RAG in Python", "description": "A practical map of a minimal, but “adult” RAG service in Python. Not an abstract pipeline, but a repository structure, Pydantic models, FastAPI dependencies, retrieval service, vector store adapter, prompt/answer layer, reindex worker, observability and tests. The idea is simple: after this volume it should be clear what files the production RAG consists of and how the request moves through the code.", "section_count": 7, "card_count": 34, "routes": { "html": "https://newruntime.com/learn/production-rag-python-reference/", "json": "https://newruntime.com/learn/production-rag-python-reference.json" } } ] }, { "slug": "agent-systems", "title": "Agent Systems", "description": "Study pipeline patterns, tool loops, protocols, orchestration frameworks, and operational agent design.", "routes": { "html": "https://newruntime.com/learn/tracks/agent-systems/" }, "guides": [ { "volume": 1, "slug": "llm-pipeline-patterns", "title": "LLM Pipeline Patterns", "description": "A comprehensive catalog of steps and tricks for building production systems based on language models. Each pattern is atomically parsed.", "section_count": 10, "card_count": 47, "routes": { "html": "https://newruntime.com/learn/llm-pipeline-patterns/", "json": "https://newruntime.com/learn/llm-pipeline-patterns.json" } }, { "volume": 6, "slug": "llm-scaffolding-reference", "title": "LLM Scaffolding: Tool Calling, Structured Output & Agent Loops", "description": "Full analysis of the orchestration layer over LLM: function calling, JSON schema, constrained decoding, ReAct/CoT patterns, agent cycle, context memory management, error handling and comparison of API providers.", "section_count": 8, "card_count": 27, "routes": { "html": "https://newruntime.com/learn/llm-scaffolding-reference/", "json": "https://newruntime.com/learn/llm-scaffolding-reference.json" } }, { "volume": 11, "slug": "mcp-agent-protocols-reference", "title": "MCP, A2A & Agent Protocols", "description": "Model Context Protocol (Anthropic, 2024) - architecture, creation of servers in TypeScript and Python, all transports, primitives, security. Agent-to-Agent (Google, 2025) - task model, AgentCard, streaming. Comparison of ecosystem protocols.", "section_count": 7, "card_count": 34, "routes": { "html": "https://newruntime.com/learn/mcp-agent-protocols-reference/", "json": "https://newruntime.com/learn/mcp-agent-protocols-reference.json" } }, { "volume": 21, "slug": "langchain-langgraph-reference", "title": "LangChain & LangGraph Under the Hood", "description": "This volume is not about “which framework is more fashionable,” but about the modern architecture of the LangChain Inc. stack. In the current version, `LangChain` is a high level with models, messages, tools, middleware and fast `create_agent`, and `LangGraph` is a low-level runtime for stateful agents: `State`, `Nodes`, `Edges`, `Command`, `thread_id`, `checkpoints`, `interrupts`, replay and long-running execution. Below is how this is really connected and what exactly happens during startup.", "section_count": 7, "card_count": 32, "routes": { "html": "https://newruntime.com/learn/langchain-langgraph-reference/", "json": "https://newruntime.com/learn/langchain-langgraph-reference.json" } }, { "volume": 30, "slug": "reasoning-models-tool-loops", "title": "Reasoning Models & Tool Loops", "description": "This volume is about a new layer of LLM engineering: models that know how to spend more inference-time compute on reasoning, and applications that make them alternate with tools. It is important to understand two things at once: what is the reasoning runtime itself and how is the loop model -> tool -> model, where state, budgets, stop conditions and engineering invariants live.", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/reasoning-models-tool-loops/", "json": "https://newruntime.com/learn/reasoning-models-tool-loops.json" } }, { "volume": 31, "slug": "clawdbot-moltbot-openclaw-reference", "title": "The OpenClaw Phenomenon and What to Learn from It", "description": "The project started as Clawdbot, was renamed Moltbot on January 27, 2026, and then OpenClaw on January 30, 2026. But the essence of the phenomenon was not in the title. This was a rare case of an open-source LLM product hitting the right intersection of UX, architecture, distribution, and memetics. This volume looks at what decisions it really made, why it went viral, and what lessons to learn from it without copying its mistakes.", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/clawdbot-moltbot-openclaw-reference/", "json": "https://newruntime.com/learn/clawdbot-moltbot-openclaw-reference.json" } } ] }, { "slug": "application-engineering", "title": "Application Engineering", "description": "Turn LLM behavior into maintainable Python services, graph runtimes, APIs, and deployable systems.", "routes": { "html": "https://newruntime.com/learn/tracks/application-engineering/" }, "guides": [ { "volume": 3, "slug": "llm-frameworks", "title": "The LLM Framework Ecosystem", "description": "Key abstractions, architectural patterns, pitfalls and selection criteria for the main frameworks of the LLM ecosystem. Each one is disassembled atomically.", "section_count": 8, "card_count": 28, "routes": { "html": "https://newruntime.com/learn/llm-frameworks/", "json": "https://newruntime.com/learn/llm-frameworks.json" } }, { "volume": 20, "slug": "python-llm-utilities-reference", "title": "The Python Utility Stack for LLM Pipelines", "description": "LLM applications live not only on models. Around them there is almost always templating, structure validation, string sanitization, JSON parsing, regex, file paths, batching, caching, async I/O and little standard library functions that save hours. This volume is not about “AI”, but about service Python, which makes the LLM pipeline stable and readable.", "section_count": 7, "card_count": 37, "routes": { "html": "https://newruntime.com/learn/python-llm-utilities-reference/", "json": "https://newruntime.com/learn/python-llm-utilities-reference.json" } }, { "volume": 22, "slug": "langchain-langgraph-codebase-reference", "title": "Production LangChain + LangGraph: Code Structure & Runtime", "description": "This volume answers a more applied question: how does a real Python project on LangChain + LangGraph spread out into files? Not “which framework is better”, but where exactly “state”, “context”, “tools”, “middleware”, “nodes”, “graph.compile(...)”, “checkpointer”, “store”, HTTP-endpoints, “thread id”, streaming and “resume” live. This is a codebase map, not a concept map.", "section_count": 7, "card_count": 34, "routes": { "html": "https://newruntime.com/learn/langchain-langgraph-codebase-reference/", "json": "https://newruntime.com/learn/langchain-langgraph-codebase-reference.json" } }, { "volume": 24, "slug": "fastapi-langgraph-langchain-microservice", "title": "Mini-Repository: FastAPI + LangGraph + LangChain as a Service", "description": "This volume does not answer the question “how to write another agent”, but the question “how to make a live external application”. At the center is one solid Python mini-repo: ‘FastAPI’ as a public HTTP/SSE layer, ‘LangGraph’ as runtime, ‘LangChain’ as a layer of models, tools and middleware, external persistence for threads, scaling, auth, health/readiness and a separate place for ‘MCP’ as a tool/data plane.", "section_count": 7, "card_count": 36, "routes": { "html": "https://newruntime.com/learn/fastapi-langgraph-langchain-microservice/", "json": "https://newruntime.com/learn/fastapi-langgraph-langchain-microservice.json" } }, { "volume": 25, "slug": "fastapi-langgraph-langchain-starter-kit", "title": "Starter Kit: FastAPI + LangGraph + LangChain by File", "description": "It's almost a project template. Not an abstract architecture, but a small, but production-focused starter kit: what files to create, what to put in them, how to assemble a ‘FastAPI’ service, where ‘LangGraph’ and ‘LangChain’ live, how to add durability, streaming, ‘resume’, tests, Docker and an optional ‘MCP’ layer.", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/fastapi-langgraph-langchain-starter-kit/", "json": "https://newruntime.com/learn/fastapi-langgraph-langchain-starter-kit.json" } }, { "volume": 26, "slug": "llm-service-deployment-devops-reference", "title": "Deployment & DevOps for an LLM Service", "description": "This volume is not about the code inside the agent, but about the operation outside: ingress, TLS, forwarded headers, “root path”, probes, secrets, queues, tracing, metrics, token/cost budgets, autoscaling, rollout/rollback and the place of “MCP” in the production circuit. This is a map of what it takes for an LLM service to not just run, but live and experience real traffic.", "section_count": 7, "card_count": 36, "routes": { "html": "https://newruntime.com/learn/llm-service-deployment-devops-reference/", "json": "https://newruntime.com/learn/llm-service-deployment-devops-reference.json" } } ] }, { "slug": "evaluation-and-improvement", "title": "Evaluation & Improvement", "description": "Measure quality, observe production behavior, validate judges, and turn failures into a data flywheel.", "routes": { "html": "https://newruntime.com/learn/tracks/evaluation-and-improvement/" }, "guides": [ { "volume": 2, "slug": "llm-observability-evals", "title": "LLM Observability & Evaluations", "description": "How to understand what is happening inside the pipeline - and what exactly is broken. Tracing, metrics, automatic evaluations, testing prompts and secure deployment of changes.", "section_count": 8, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/llm-observability-evals/", "json": "https://newruntime.com/learn/llm-observability-evals.json" } }, { "volume": 12, "slug": "eval-process-llm-judge-reference", "title": "Evaluation Process & LLM-as-Judge", "description": "How to build the process of evaluating LLM systems from scratch: minimum viable eval, guardrails vs evaluators, why a binary assessment is better than a scale of 1–5, negative scenarios, LLM-as-judge with correlation to people, detection of degradation after release, synthetic data - when it helps and when it harms.", "section_count": 7, "card_count": 23, "routes": { "html": "https://newruntime.com/learn/eval-process-llm-judge-reference/", "json": "https://newruntime.com/learn/eval-process-llm-judge-reference.json" } }, { "volume": 27, "slug": "production-observability-eval-loop", "title": "The Production Observability & Evaluation Loop", "description": "This volume does not repeat the general review of evals. It shows the operational cycle of the team: how incident cases, datasets, offline evals, human review, canary gates and rollout/rollback decisions are born from production traces and user signals. It’s not “what evals are,” it’s “how the team lives with evals and observability every day.”", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/production-observability-eval-loop/", "json": "https://newruntime.com/learn/production-observability-eval-loop.json" } }, { "volume": 29, "slug": "data-flywheel-reference", "title": "The Data Flywheel: From Production Cases to Release Gates", "description": "This volume is about the main engine of a high-quality LLM team: how production traces and user pain turn into curated cases, label taxonomy, human review queue, regression set, canary set and decisions about what to fix prompt, what to retriever, and what to train. So it's not \"where to get the dataset,\" but how the team grows it out of their own work and turns the data into a system improvement cycle.", "section_count": 7, "card_count": 35, "routes": { "html": "https://newruntime.com/learn/data-flywheel-reference/", "json": "https://newruntime.com/learn/data-flywheel-reference.json" } }, { "volume": 32, "slug": "llm-judge-meta-evaluation-reference", "title": "LLM-as-Judge Meta-Evaluation", "description": "A separate volume is not about eval in general, but about the validation of the judge itself: agreement with people, metrics for binary and ordinal verdicts, resistance to repeated runs, confidence calibration, bias audits, pairwise ranking and minimum reporting standard. Agreement → classifier view → stability → calibration → bias → reporting.", "section_count": 7, "card_count": 25, "routes": { "html": "https://newruntime.com/learn/llm-judge-meta-evaluation-reference/", "json": "https://newruntime.com/learn/llm-judge-meta-evaluation-reference.json" } }, { "volume": 33, "slug": "base-metrics", "title": "Core Metrics for LLM Pipelines", "description": "One volume about the most useful metrics for LLM systems: from average, variance and standard deviation to accuracy, precision, recall, F1, MRR, MAP, nDCG@k, calibration, pass@k, latency and cost per success. Each card answers four questions: what it measures, how to calculate it, how to read, and where to apply it in the pipeline.", "section_count": 5, "card_count": 26, "routes": { "html": "https://newruntime.com/learn/base-metrics/", "json": "https://newruntime.com/learn/base-metrics.json" } } ] }, { "slug": "ml-and-decision-systems", "title": "ML & Decision Systems", "description": "Connect language-model work to statistics, encoders, classical machine learning, forecasting, causality, and bandits.", "routes": { "html": "https://newruntime.com/learn/tracks/ml-and-decision-systems/" }, "guides": [ { "volume": 8, "slug": "llm-stats-reference", "title": "Statistics for Evaluating LLM Systems", "description": "Basic concepts of statistics as applied to LLM experiments: quality metrics, variance and confidence intervals, hypothesis testing, A/B tests, LLM-as-judge, evaluation pitfalls and a practical checklist for a valid experiment.", "section_count": 7, "card_count": 24, "routes": { "html": "https://newruntime.com/learn/llm-stats-reference/", "json": "https://newruntime.com/learn/llm-stats-reference.json" } }, { "volume": 10, "slug": "bert-encoder-reference", "title": "BERT, Encoders & Non-Generative Models", "description": "Taxonomy of transformer architectures: encoder-only, decoder-only, encoder-decoder. How BERT works and why bidirectional is better to understand. BERT family. Fine-tuning patterns. T5 and seq2seq. When a small specialized model beats GPT-4. A practical map for choosing an architecture for a task.", "section_count": 7, "card_count": 23, "routes": { "html": "https://newruntime.com/learn/bert-encoder-reference/", "json": "https://newruntime.com/learn/bert-encoder-reference.json" } }, { "volume": 16, "slug": "classical-ml-reference", "title": "Classical Machine Learning in Plain English", "description": "A cheat sheet for talking with ML specialists in one language: what are data, features, target, loss, generalization and prediction; what problems are solved by linear models, trees, SVM, kNN, ensembles, clustering and PCA; and why the transition to neural networks did not cancel the basic mechanics of errors and optimization, but scaled it.", "section_count": 7, "card_count": 31, "routes": { "html": "https://newruntime.com/learn/classical-ml-reference/", "json": "https://newruntime.com/learn/classical-ml-reference.json" } }, { "volume": 17, "slug": "forecasting-causal-bandits", "title": "Forecasting, Causal Inference & Bandits", "description": "The next layer after classic ML. Not just “predict the label”, but understand three different questions: what will happen next, what will happen if we intervene, and what is better to show right now with incomplete information. These are three different formulations of the problem, with different metrics, leakage risks and different language of communication with researchers and product teams.", "section_count": 7, "card_count": 32, "routes": { "html": "https://newruntime.com/learn/forecasting-causal-bandits/", "json": "https://newruntime.com/learn/forecasting-causal-bandits.json" } } ] } ] }