ALL ARTICLES

All Articles

Deep dives into LLM system architectures, inference engine internals, AI Agents, and production engineering practices.

⌘ K

📚 Curated Technical Series

End-to-end engineered deep dives organized into progressive learning roadmaps.

📚 AI Agent Architect Series 14 Articles

The Production AI Agent Architect Handbook

Master production-grade AI Agent architectures in 2026: from execution loops and state machines to MCP, skills, multi-agent orchestration, and observability.

Start Reading →
📚 Inference Engine Series 10 Articles

Production LLM Inference Engines: Evolution, Architecture, and Future

Master LLM inference systems from first principles: Roofline modeling of Prefill/Decode, KV Cache & MLA memory optimization, PagedAttention, Continuous Batching, P/D disaggregation, and in-depth engine architectures across vLLM, SGLang, TensorRT-LLM, and llama.cpp.

Start Reading →
📚 Container & K8s Series 13 Articles

From Docker to Kubernetes: Cloud-Native Container & Cluster Orchestration Handbook

Master containerization and cluster orchestration from first principles: Linux namespaces, cgroups v2, SwarmKit, K8s control plane; real-world software architecture on K8s (gRPC/zero-downtime, Local NVMe/RocksDB/fencing); hacking K8s internals (Scheduling Framework plugins, NRI runtimes, Aggregated APIServer); and 2026 AI GPU scheduling.

Start Reading →
📚 Networking Series 12 Articles

Computer Networking Masterclass: From Ethernet Principles to Hyperscale InfiniBand Architecture

A ground-zero masterclass to 10,000-GPU AI networking: from physical voltages, twisted pairs, and optical fibers to hubs, collision domains, switches, and MAC/ARP; step-by-step binary derivations of IP addressing, subnet masks, default gateways, VLANs, DHCP, and NAT; in-depth DNS, Socket 5-tuples, TCP 11-state machines, and BBR congestion control; Linux kernel NAPI, sk_buff, and eBPF XDP; datacenter traditional 3-tier vs 2-tier Spine-Leaf fabrics and EVPN-VXLAN; leading up to AI supercomputing: lossless RoCEv2, native InfiniBand NDR/XDR link speeds, credit flow control, Rail-Optimized Fat-Trees, Adaptive Routing, SHARP, and bare-metal OFED/NCCL performance tuning.

Start Reading →
2026.10.21
Inference Architecture 📌 Pinned

Inside DeepSeek's Trillion-Token Engine: DeepInfer and deepseek-recipe Architecture from Silicon to Protocol Layer

From physical silicon foundations and kernel matrices to 1:1 PD disaggregation topologies, DSpark dynamic speculative decoding, SWA bounded replay, deepseek-recipe protocol layers, and $38/GPU/h unit economics: a complete architectural dissection of DeepSeek's production inference stack.

2026.10.05
Production Ops & NCCL Tuning 📚 Networking Series

Production InfiniBand Deployment, Cluster Operations, and NCCL Tuning: OFED Drivers, OpenSM HA, ibdiagnet Fabric Auditing, and GPUDirect RDMA

Production InfiniBand cluster operations: MLNX_OFED driver stacks, OpenSM high availability, ibdiagnet fabric health auditing, and NCCL GPUDirect RDMA tuning.

Computer Networking InfiniBand OFED DOCA OpenSM HA ibdiagnet GPUDirect RDMA nvidia-peermem NCCL Tuning
2026.10.04
Fat-Tree & Adaptive Routing 📚 Networking Series

InfiniBand AI Cluster Networking in Practice: Fat-Tree Topologies, Rail-Optimized Architecture, Adaptive Routing (AR), and In-Network Reduction (SHARP)

AI cluster fabric topologies: Non-blocking Fat-Trees, Rail-Optimized cabling, Adaptive Routing (AR), SHARP in-network aggregation, and congestion mitigation.

Computer Networking InfiniBand Fat-Tree Rail-Optimized FTree Up/Down Routing Adaptive Routing SHARP DGX Cluster
2026.10.03
InfiniBand & Subnet Manager 📚 Networking Series

InfiniBand Architecture First Principles: Physical Link Rates, Credit-Based Link Flow Control, and Subnet Manager Fabric Orchestration

InfiniBand hardware architecture: SDR to NDR/XDR link speeds, 4b/5b to PAM4 modulation, credit-based flow control, Virtual Lanes, and OpenSM subnet management.

Computer Networking InfiniBand NDR 400G XDR 800G Credit-Based Flow Control Cut-Through Switching Subnet Manager OpenSM GUID & LID
2026.10.02
Linux Kernel & eBPF Networking 📚 Networking Series

Linux Kernel Networking Subsystem in Depth: From NIC Drivers, NAPI, and Ring Buffers to eBPF XDP Wire-Speed Forwarding

Linux kernel networking internals: NIC RX Ring Buffers, DMA transfers, NAPI hybrid polling, sk_buff lifecycle, RSS multi-queue affinity, and eBPF XDP wire filtering.

Computer Networking Linux Kernel NAPI Ring Buffer sk_buff RSS eBPF XDP AF_XDP
2026.10.02
RDMA & RoCEv2 📚 Networking Series

RDMA High-Performance Networking Foundations: Kernel Bypass, Zero-Copy, Queue Pairs, and Lossless RoCEv2 (PFC/ECN) Architecture

RDMA high-performance networking: Kernel bypass, hardware zero-copy, Queue Pair ibverbs verbs, and lossless RoCEv2 with 802.1Qbb PFC and DCQCN congestion control.

Computer Networking RDMA Kernel Bypass Zero-Copy Queue Pair RoCEv2 PFC ECN DCQCN
2026.10.01
Datacenter & Leaf-Spine 📚 Networking Series

Modern Data Center Network Architecture First Principles: Clos Topologies, Leaf-Spine Fabrics, BGP Underlay, and EVPN-VXLAN Large Layer-2 Virtualization

First-principles guide to datacenter networking: Clos topologies, 2-Tier/3-Tier Leaf-Spine fabrics, RFC 7938 eBGP Underlay, ECMP hashing, and EVPN-VXLAN large Layer-2 Overlay.

Computer Networking Data Center Traditional 3-Tier Network Clos Topology Leaf-Spine BGP Underlay ECMP Hash Polarization VXLAN EVPN
2026.10.01
Transport Layer Bridge & DNS 📚 Networking Series

Application & Transport Layer Bridges: DNS Resolution, Sockets, Ports, and UDP vs TCP Foundations

Application and transport layer bridges: DNS recursive resolution, Anycast root servers, 5-tuple socket multiplexing, and architectural UDP vs TCP trade-offs.

Computer Networking DNS Root Server Port Socket 5-Tuple UDP TCP
2026.09.30
LAN & VLAN Infrastructure 📚 Networking Series

Enterprise LAN Infrastructure: VLAN Segmentation (802.1Q), Dynamic DHCP, and NAT Port Forwarding

Enterprise LAN infrastructure: IEEE 802.1Q VLAN trunking, DORA DHCP address pools, Router-on-a-Stick, L3 routing, and Linux iptables NAPT port forwarding.

Computer Networking LAN VLAN 802.1Q DHCP DORA NAT NAPT conntrack
2026.09.30
Congestion Control & QUIC 📚 Networking Series

TCP Congestion Control Evolution & High-Performance Transport: From Reno and Cubic to BBR Mathematical Models, and HTTP/2 to HTTP/3 (QUIC)

TCP congestion control evolution: loss-based Reno, Linux default Cubic polynomial curves, Google BBR pacing models, and HTTP/3 QUIC 0-RTT transport.

Computer Networking Congestion Control TCP Reno TCP Cubic Google BBR Bufferbloat HTTP/2 HTTP/3 QUIC
2026.09.29
IP Addressing & Subnet Mask 📚 Networking Series

IP Addressing and Subnetting First Principles: Binary Arithmetic, Subnet Masks, CIDR, and Default Gateway Routing

Deep dive into IP addressing: IPv4 32-bit binary representation, bitwise AND subnet masking, CIDR supernetting, default gateways, and Linux routing tables.

Computer Networking IP Address Subnet Mask CIDR Bitwise AND Default Gateway Routing Table
2026.09.29
IP Routing & TCP State Machine 📚 Networking Series

Network & Transport Layers in Depth: IP Routing, CIDR, TCP 11-State Machine, and Sliding Window First Principles

Layer 3 and Layer 4 networking: IPv4/IPv6 headers, Linux kernel LPM routing, TCP 11-state machine transitions, SYN cookies, and sliding window flow control.

Computer Networking IP Routing CIDR TCP 3-Way Handshake TIME_WAIT Sliding Window SYN Flood TCP_NODELAY
2026.09.28
Zero-Foundation Networking & Layer 2 📚 Networking Series

Computer Networking from Scratch: Bits, Physical Media, Hub Collision Domains, and Switch MAC Addressing First Principles

Computer networking from scratch: physical voltages, twisted pairs, optical fibers, collision domains, Ethernet frames, Layer-2 switches, and ARP broadcast mechanics.

Computer Networking Physical Layer Ethernet Hub Switch Collision Domain Broadcast Domain MAC Address ARP
2026.09.25
Container Networking 📚 Container & K8s Series

Container Networking Deep Dive: veth-pair, Linux Bridge, iptables NAT, and Cross-Host Topology

Container networking from scratch: Network Namespaces, veth-pairs, Linux bridge docker0 forwarding, iptables DNAT/SNAT, and Host vs Bridge vs Macvlan comparisons.

Container Networking veth-pair Linux Bridge iptables NAT Docker VXLAN
2026.09.25
Container Internals 📚 Container & K8s Series

Docker Internals from First Principles: Linux Namespaces, cgroups v2, and OverlayFS Union Mounts Deep Dive

Docker internals from first principles: Linux Namespaces isolation, cgroups v2 resource limits, OverlayFS layered union mounts with CoW, and OCI runc execution.

Docker Linux Kernel Namespace cgroups v2 OverlayFS runc containerd
2026.09.25
Cluster Orchestration 📚 Container & K8s Series

Lightweight Cluster Orchestration: Docker SwarmKit Architecture, Raft Consensus, and Ingress Routing Mesh

Docker Swarm architecture deep dive: SwarmKit Raft consensus, VXLAN cross-host overlay networking, IPVS Ingress Routing Mesh, and Kubernetes trade-offs.

Docker Swarm SwarmKit Raft Routing Mesh Overlay Network VXLAN IPVS
2026.09.25
Application Networking 📚 Container & K8s Series

Application Networking on Kubernetes: The gRPC Load Balancing Trap, Service Mesh, and Zero-Downtime Draining Sequences

Kubernetes application networking: HTTP/2 gRPC load balancing, Envoy service mesh architecture, xDS control planes, and zero-downtime rolling deployment strategies.

Kubernetes gRPC HTTP/2 Zero Downtime preStop EndpointSlice Service Mesh Envoy
2026.09.25
K8s Control Plane 📚 Container & K8s Series

Kubernetes Control Plane Deep Dive: Declarative APIs, etcd Consensus, Scheduler, and Controller Reconciliation Loops

Kubernetes control plane architecture: declarative reconciliation loops, informers, workqueue patterns, and optimistic concurrency control with etcd.

Kubernetes Control Plane etcd apiserver Scheduler Controller Informer Reconciliation
2026.09.25
Control Plane Customization 📚 Container & K8s Series

Hacking the Kubernetes Control Plane: WatchCache Internals, Aggregated APIServers, APF Shuffle Sharding, and 10k-Node etcd Sharding

Advanced Kubernetes control plane internals: Aggregated API Servers, API Priority and Fairness (APF) flow control, CRD scaling limits, and etcd performance tuning.

Kubernetes Control Plane WatchCache resourceVersion Aggregated APIServer APF etcd Shuffle Sharding Scale
2026.09.25
Database Storage 📚 Container & K8s Series

Production Databases and Storage on Kubernetes: Local NVMe Passthrough, RocksDB/WAL Tuning, and Fencing Split-Brain Protection

Running databases on Kubernetes: Local PV NVMe tuning, page cache dirty ratio optimization, RocksDB/MySQL WAL Direct I/O, and STONITH node fencing.

Kubernetes Database Local PV NVMe RocksDB WAL Page Cache Fencing STONITH
2026.09.25
AI GPU Scheduling 📚 Container & K8s Series

2026 AI Computing Infrastructure: Kubernetes GPU Operator, MIG Partitioning, Topology-Aware Scheduling, and Auto-scaling Inference Engines

AI infrastructure on Kubernetes: NVIDIA GPU Operator automation, MIG slicing, Kubelet Topology Manager NUMA alignment, Dynamic Resource Allocation, and KEDA scaling.

Kubernetes GPU Operator MIG Topology Manager DRA vLLM SGLang KEDA
2026.09.25
K8s Networking 📚 Container & K8s Series

Kubernetes Networking Panorama: CNI Specification, Calico BGP, Cilium eBPF, and Gateway API Architecture

Kubernetes CNI networking guide: Flannel vs Calico topologies, Cilium eBPF socket redirection to bypass kube-proxy, and modern Gateway API traffic governance.

Kubernetes CNI Cilium eBPF Calico BGP Gateway API kube-proxy
2026.09.25
Operator Pattern 📚 Container & K8s Series

Kubernetes Extensibility: The Operator Pattern, Custom Resource Definitions (CRD), and KubeBuilder in Production

Production Kubernetes Operator guide: Kubebuilder architecture, CRD OpenAPI validation, Controller-Runtime reconciliation, and custom Go stateful controllers.

Kubernetes Operator CRD KubeBuilder Controller-Runtime Go Finalizer
2026.09.25
Node Runtime Customization 📚 Container & K8s Series

Hacking Kubernetes Nodes & Runtimes: Breaking PLEG Bottlenecks, NRI Plugins, Kata/gVisor Sandboxes, and cgroups v2 Tuning

Kubernetes node runtime internals: Kubelet syncLoop, Evented PLEG, containerd Node Resource Interface (NRI) plugins, Kata microVMs, and gVisor sandboxing.

Kubernetes Kubelet PLEG Evented PLEG NRI Containerd RuntimeClass Kata Containers gVisor cgroups v2 Sysctl
2026.09.25
Scheduler Customization 📚 Container & K8s Series

Hacking the Kubernetes Scheduler: Custom Plugins via Scheduling Framework, Volcano DRF Math, and Descheduler Dynamic Rebalancing

Kubernetes custom scheduling: 11 Scheduling Framework extension points, CycleState caching, Volcano DRF algorithms, and Go Gang Scheduling plugin implementation.

Kubernetes Scheduling Framework Gang Scheduling Descheduler Volcano DRF kube-scheduler Go Extension Points
2026.09.25
K8s Storage 📚 Container & K8s Series

Kubernetes Storage Architecture: CSI Specification, Dynamic PV/PVC Provisioning, and StatefulSet Guarantees

Cloud-native storage architecture: StorageClass, PV/PVC decoupling, CSI provision/attach/stage/mount lifecycles, and StatefulSet deterministic volume binding.

Kubernetes CSI StatefulSet PersistentVolume StorageClass VolumeAttachment Headless Service
2026.09.24
Batching & Scheduling 📚 Inference Engine Series

Evolution of High-Concurrency Batching: From Continuous Batching to Chunked Prefill Eliminating Head-of-Line Blocking

High-throughput LLM serving: Orca iteration-level continuous batching, head-of-line blocking mitigation, and Chunked Prefill with decode piggybacking in vLLM.

Continuous Batching Chunked Prefill Head-of-Line Blocking Orca Sarathi-Serve vLLM
2026.09.24
Kernel Optimization 📚 Inference Engine Series

Evolution of Attention Kernels: From FlashAttention-1/2/3 SRAM Tiling to FlashInfer Unified Heterogeneous Serving

Deep dive into GPU attention kernels: FlashAttention-1 online softmax, FA-2 parallelism, FA-3 Hopper TMA asynchronous pipelines, and FlashInfer variable-length batching.

FlashAttention FlashInfer SRAM Tiling Online Softmax Split-K Attention Hopper TMA WGMMA
2026.09.24
Inference Engines 📚 Inference Engine Series

Production LLM Inference Engines Teardown: vLLM v1 vs. SGLang vs. TensorRT-LLM vs. llama.cpp Internals

Codebase teardown of top LLM inference engines: vLLM multi-step scheduling, SGLang RadixAttention, TensorRT-LLM in-flight batching, and llama.cpp quantization.

vLLM SGLang TensorRT-LLM llama.cpp Scheduler Kernel Fusion
2026.09.24
Roofline Modeling 📚 Inference Engine Series

From model.generate() to the Roofline Model: The Physics of Prefill and Decode Divergence

Why do modern GPUs with hundreds of TFLOPS idle at less than 5% Tensor Core utilization during LLM inference? A first-principles exploration of the autoregressive loop, the Roofline model, and the mathematical divergence between compute-bound Prefill and memory-bound Decode.

Inference Engine Roofline Model Prefill vs Decode Arithmetic Intensity TTFT vs TPOT
2026.09.24
Attention Architecture 📚 Inference Engine Series

Model Architecture Driving Inference Systems: From MHA/GQA to DeepSeek MLA Matrix Absorption and Memory Minimalism

Attention evolution for LLM serving: MHA memory bottlenecks, GQA grouping trade-offs, DeepSeek MLA low-rank latent projections, Decoupled RoPE, and Matrix Absorption.

MLA GQA DeepSeek Matrix Absorption KV Cache Compression FlashMLA Decoupled RoPE
2026.09.24
MoE & Sparsity 📚 Inference Engine Series

MoE Inference Internals: Expert Parallelism (EP), Dynamic Routing Gating, and All-to-All Overlapping

MoE inference internals: DeepSeek-V3 gating, Expert Parallelism (EP) All-to-All communication, CUTLASS Grouped GEMM kernels, and DualPipe overlap schedules.

MoE Expert Parallelism All-to-All Grouped GEMM DeepSeek-V3 DualPipe
2026.09.24
Memory Virtualization 📚 Inference Engine Series

Memory Virtualization in Inference Engines: PagedAttention and the Elimination of Memory Fragmentation

Why did early LLM serving systems waste 60% to 80% of GPU memory? A deep architectural exploration of vLLM's PagedAttention, logical-to-physical block mapping, zero-copy Copy-on-Write sharing, and non-contiguous CUDA attention kernels.

PagedAttention KV Cache Memory Fragmentation vLLM Virtual Memory
2026.09.24
Inference Systems 📚 Inference Engine Series

Prefill-Decode (P/D) Disaggregation Architecture: Compute-Memory Decoupling, RDMA Distributed KV Cache Transfer, and Cluster-Scale Pooling

Prefill-Decode (P/D) Disaggregation architecture: compute vs memory isolation, MLA cross-node bandwidth modeling, GPUDirect RDMA KV transfers, and queuing theory.

Disaggregated Serving KV Cache RDMA DistServe Mooncake Roofline
2026.09.24
Prefix Caching 📚 Inference Engine Series

Prefix Caching and State Reuse: From Hash Block Addressing to SGLang RadixAttention and Dynamic Tree Eviction

LLM state reuse internals: vLLM hash-chained block caching vs SGLang RadixAttention tree-structured prefix matching, node splitting, and LRU leaf eviction.

Prefix Caching RadixAttention Radix Tree KV Cache Reuse SGLang vLLM LRU Eviction
2026.09.24
Future Architectures 📚 Inference Engine Series

The Future of LLM Inference: Test-Time Compute, Reasoning Scheduling, and Tiered Cluster Storage

Inference architectures for reasoning models: Test-Time Compute scaling, MCTS speculative tree scheduling, thinking budget governors, and tiered KV cache pools.

Test-Time Compute Reasoning Tiered Storage MCTS Speculative Decoding Future Architecture
2026.09.21
Agent Memory 📚 AI Agent Architect Series

AI Agent Memory Architecture: From Working Memory to Episodic Memory & Hierarchical Graph RAG

Design agent working, episodic, and long-term memory with sourced retrieval concepts, a clearly scoped Python prototype, provenance, ACLs, conflict handling, and deletion.

Agent Memory Working Memory Graph RAG Episodic Memory MemGPT
2026.09.20
State Machine 📚 AI Agent Architect Series

Agentic Loops & State Machine Design: From ReAct to Deterministic Control Flows

Why prompt chaining and unconstrained ReAct loops fail in production AI systems. A deep architectural dissection of agent failure modes, Finite State Machine (FSM) graph flows, tool-calling resilience, and circuit breakers with runnable code.

Agent Architecture State Machine ReAct Control Flow Circuit Breaker
2026.09.18
Browser Agents 📚 AI Agent Architect Series

Under the Hood of Browser-use (100k+ Stars): DOM Tree Distillation, Vision Grounding, and Production Web Agents

Why do traditional Selenium and Playwright scripts constantly break against modern web frontends? We dissect the architecture of Browser-use, the breakout open-source project with over 100k GitHub stars: DOM tree pruning, Set-of-Mark (SoM) visual coordinate grounding, state machine resilience, and end-to-end production recipes.

2026.09.18
Engine Architecture

SGLang vs vLLM: Prefix Caching, Structured Outputs, and Reproducible Evaluation

Compare SGLang RadixAttention and vLLM APC, structured-output backends, minimal serving baselines, and reproducible cold/warm-cache latency and throughput evaluation.

2026.09.18
Speculative Decoding

Speculative Decoding in Production: From Draft Models to EAGLE-3 Dynamic Trees for 3x-5x Lossless Acceleration

Why is autoregressive LLM decoding fundamentally bottlenecked by memory bandwidth? We dissect the mathematical proof of lossless distribution invariance in speculative decoding, trace its evolution from dual-model drafts to EAGLE-2/3 dynamic draft trees, and provide production configurations in vLLM and SGLang.

2026.09.18
RL & Reasoning

Test-Time Compute and GRPO in Practice: From PPO to Critic-Free Reinforcement Learning

A deep dive into the paradigm shift from pre-training scaling laws to test-time compute. We deconstruct the mathematical derivation of DeepSeek-R1's Group Relative Policy Optimization (GRPO), critic-free architecture advantages, emergent self-reflection in long reasoning traces, and a complete, reproducible hands-on implementation.

2026.09.07
Cluster Deployment

Production Deployment of DeepSeek-V4 and Kimi K3: 32-GPU Topologies, Memory Math, and Real-World Troubleshooting

Comprehensive production guide for hosting DeepSeek-V4-Pro (CSA+HCA) and Kimi K3 (KDA+MLA): covering 4-node/32-GPU and 8-node/64-GPU topologies, per-rank GPU memory budgeting, six hardcore production pitfalls (NUMA crossing, MoE routing skew, CUDAGraph pseudo-OOM, PFC deadlock), Ray and KubeRay orchestration.

2026.09.07
Chinese LLMs

Kimi K3 vs GLM-5.3 vs DeepSeek-V4: Architecture, Benchmarks and Deployment

Compare Kimi K3, GLM-5.3, and DeepSeek-V4-Pro with sourced architecture facts, matching benchmark versions, checkpoint formats, and workload evaluation plans.

2026.09.07
Environment Scaling 📚 AI Agent Architect Series

Beyond Simple Prompts: How Environment Scaling Is Reshaping Autonomous Agents in 2026

Understand agent environment scaling through task diversity, reset and verification, a sourced GLM-5.3 result, and container execution with cleanup after timeouts.

2026.09.07
Architecture Evolution

Kimi KDA, DeepSeek MLA and V4 CSA/HCA: Long-Context Cache and GPU Memory

Understand KDA recurrent state, MLA latent caches, and DeepSeek-V4 CSA/HCA sequence compression, with explicit memory formulas and reproducible measurement rules.

2026.07.16
Self-Correction 📚 AI Agent Architect Series

Evolving Models at Runtime: From Basic Reflection to MCTS-based Test-Time Compute

The potential of LLMs extends beyond pre-trained parameters. We dive deep into the frontier of Test-Time Compute: from Actor-Critic architecture to leveraging Monte Carlo Tree Search (MCTS) to decode the limits of Agent self-correction.

2026.07.15
Orchestration & Evals 📚 AI Agent Architect Series

2026 AI Paradigm Shift: Distributed Agent Orchestration & Evals to Combat Error Compounding

As LLMs move into complex enterprise production, how do we use distributed orchestration to combat error compounding? How do we build a statistically significant Evals system?

2026.06.28
Loop Engineering

Deep Dive into AI Agent Architecture Evolution: From Prompt to Loop Engineering

A deep dive into the evolution of AI Agent architectures, exploring the 4-layer control plane extrapolation from Prompt, Context, Harness to Loop Engineering, and the 4 diseases of the ReAct architecture.

2026.06.16
Tool Use 📚 AI Agent Architect Series

Advanced Tool Use in Agent Architecture: Dynamic Discovery, Sandboxing, and Self-Healing Recovery

Implement dynamic tool retrieval, MCP initialization and pagination, gVisor container execution, cleanup after timeouts, and bounded recovery with Python examples.

Function Calling MCP Sandbox Error Recovery
2026.06.16
Architecture 📚 AI Agent Architect Series

Building a Lightweight Agent Framework from Scratch: State Machines and Event Streams

Build a Python agent state machine with SQLite approval checkpoints, restart recovery, single-use approvals, rejection handling, step budgets, and async events.

Agent Framework State Machine Event Stream LangGraph
2026.06.16
Multi-Agent 📚 AI Agent Architect Series

Communication Protocols and Concurrency Control in Multi-Agent Systems

Build asyncio agent mailboxes and a message bus with isolated payload copies, bounded delivery, graceful shutdown, CAS document updates, and token-bucket limiting.

Actor Model Concurrency AutoGen Distributed
2026.06.15
Observability 📚 AI Agent Architect Series

Agent Observability & Debugging: The Path from Black Box to White Box

AI Agents are not traditional software; we are debugging the reasoning process rather than the code itself. This article explores Trajectory Evaluation, LLM-as-a-Judge, and practical applications of mainstream Agent observability tools like LangSmith and Langfuse.

Observability Debugging Trajectory Evaluation LangSmith
2026.06.15
Context Engineering

Context Engineering Guide: Managing Context Window like RAM

The hottest concept in 2026, evolving from Prompt Engineering to Context Engineering. A deep dive into managing the context window through Write, Select, Compress, and Isolate strategies to solve long-context amnesia, hallucinations, and context poisoning.

Context Engineering Memory Management RAG
2026.05.04
AI Coding

AI Coding Mastery: From 'Build Me an X' to Architecture Orchestrator

Tools don't matter — methodology does. A deep dive into six core methods for mastering AI coding: Spec-Driven Development, Context Engineering, TDD Verification Loops, Multi-Agent Orchestration, Advanced Prompting, and Session Hygiene. Plus a 20+ tool matrix and five anti-patterns to avoid.

2026.04.22
LLM Evaluation

Reject Benchmark Hacking: How to Build an LLM Evaluation System for Your Business (LLM-as-a-Judge)

Cease the obsession with writing more code; shift focus to deep evaluation thinking. We deconstruct LLM-as-a-Judge biases, the mathematics behind metrics, and reshaping CI/CD defenses for probabilistic systems.

2026.04.22
Quantization Hands-on

LLM Quantization Hands-On Guide: Four Routes from Zero to Production

Hands-on LLM quantization guide: download and run GGUF models (Qwen3-8B-Q4_K_M.gguf, llama.cpp, Ollama), quantize with AWQ/GPTQ, and deploy vLLM FP8 in production with copy-paste code.

2026.04.15
Tech Evolution

The Critical Crossroads in AI History: Why Was *That One* Chosen Every Time?

A retrospective of six pivotal technology crossroads in AI's seventy-year history, dissecting the compute constraints, data dividends, and scalability logic behind each historical choice.

2026.04.14
Serving & Deployment

vLLM Online Inference in Production: From Architecture to Token Billing

A deep dive into vLLM's core architecture (PagedAttention, continuous batching, APC prefix caching, speculative decoding) for online serving. Covers OpenAI-compatible API setup, performance tuning, token billing systems, and complete Docker deployment with Prometheus monitoring.

2026.04.05
GPU & Driver Stack

Mapping the NVIDIA GPU Driver Stack: From Kernel Modules to Container Runtimes

A deep dive into the complex Linux NVIDIA GPU driver package structures. Understand the 5-layer architecture bridging nvidia-dkms, libnvidia, nvidia-utils, and driver metapackages. Plus, discover enterprise best practices and troubleshooting guides for 4 core deployment scenarios, including Docker model servers and DGX clusters.

2026.03.31
Quantization Precision

LLM Quantization Precision Guide: From FP32 to 1-bit, How Much Quality Do You Actually Lose?

Understand FP8, INT8, INT4, and NF4 across weights, activations, and KV cache, with complete memory budgets, speed tradeoffs, calibration, and quality evaluation.

2026.03.15
Runtime Practices 📚 AI Agent Architect Series

7 Runtime Practices for Building AI Agents

Based on a real data analysis agent project, this article distills 7 reusable Agent Runtime practices covering state exposure, tool design, context control, guardrails, delegation, and trace-driven iteration.

Agent Runtime Tool Calling Guardrail Trace
2026.03.12
MCP Protocol 📚 AI Agent Architect Series

MCP Deep Dive: The USB-C Port for AI

From architecture to hands-on development, a complete guide to the Model Context Protocol. Includes Python SDK tutorial, security mechanisms, and ecosystem comparison.

2026.03.12
Agent Skills 📚 AI Agent Architect Series

Skills Deep Dive: Give Your AI Coding Assistant a Professional Brain

From core principles to cross-platform practice, a complete guide to the AI coding assistant Skills system. Covers SKILL.md mechanics, six-platform comparison, hands-on writing guide, and best practices.

Claude Code Cursor GitHub Copilot OpenAI Codex
2026.03.09
Prompt Engineering

Prompt Engineering Practice Guide

An in-depth exploration of designing effective prompts to improve model output quality. Covers core techniques like Few-Shot, Chain-of-Thought, and ReAct with practical examples.

GPT-5.4 Claude 4.6 Prompt
2026.03.07
Tech Trends

Deep Dive into 11 AI Foundation Model Trends in 2026

From Thinking reasoning modes to Agentic applications, a deep dive into the top 11 trends in AI foundation models for 2026.

2026.03.05
Agent Building 📚 AI Agent Architect Series

Building AI Agent Applications from Scratch

A step-by-step guide to building intelligent agent systems using LangChain and the Claude API. Includes complete code and architecture design.

2026.03.03
RAG Architecture

Retrieval-Augmented Generation (RAG) in Practice: Strategies & Production Best Practices

A complete guide on how to use retrieval-augmented generation strategies and production best practices. Covers vector databases, semantic chunking, ColBERT reranking, GraphRAG, and automated Ragas evaluation.

2026.03.01
Model Benchmark

2026 Mainstream Foundation Models Comparison: GPT-5.4 vs Claude Opus 4.6 vs Gemini 3.1 Pro

Compare GPT-5.4, Claude 4.6, and Gemini 3.1 Pro APIs with sourced capabilities, token prices, SDK examples, fair evaluation rules, and self-hosting cost formulas.

2026.02.28
Multimodal LLMs

Multimodal AI Models Starter Guide

Explore the vision and text capabilities of multimodal models like GPT-5.4 and Gemini 3.1 Pro, with practical use cases in image and video analysis.

2026.02.25
Fine-Tuning

LLM Fine-Tuning Guide: How It Works, Real-World Use Cases, and Workflows

Discover how LLM fine-tuning works under the hood, explore proven enterprise use cases (LoRA, QLoRA, Full Fine-Tuning), and learn end-to-end workflows from data preparation to vLLM serving.