Knowledge Share
Technical articles, tutorials, and insights
Workflow Series (09): Framework Comparison — Prompt-based, LangGraph, Temporal, or n8n?
The core differences between four workflow approaches: Prompt-based (Markdown + JSON state file), LangGraph (Python graph-structured state machine), Temporal (enterprise-grade Durable Execution), and n8n (visual low-code). Not which is better — which fits which context. LangGraph's State/Node/Edge concepts map directly to Prompt-based equivalents.
Skill Series (05): Skill Workflow Chaining — 4 Patterns, Real Data, Parallel Speedup 1.5x
Implement and benchmark 4 Skill chaining patterns: sequential (35.1s), parallel fan-out (1.5x speedup, not the theoretical 3x), conditional routing (3/3 correct), feedback loop (first iteration scored 8/10, no retries needed). The parallel speedup falls short because Amdahl's Law applies: the sequential merge step caps total speedup at ~2x.
Agent Series (22): Context Engineering Deep Dive — Quantifying Three Context Management Strategies
Using a 30-turn synthetic conversation and 4 early-decision recall tests, this article quantifies three context management strategies: Naive (full history), Sliding Window (truncation), and Rolling Summary. The data reveals three counter-intuitive findings: truncation's cost far exceeds intuition, summaries occasionally outperform raw history, and compression loss is a real bug, not statistical noise.
Agent Series (23): Web Agent — Giving Your Agent Real Eyes on the Internet
Build a Web Agent from scratch: DuckDuckGo search + page fetching + LangGraph execution graph. Focus on three engineering guards — Token Budget truncation, Step Limit anti-loop protection, URL error handling — with data from actual run output.
Agent Series (20): Harness in Production — From Single File to Reusable Package
Splitting Article 19's single-file Harness into a reusable Python package: registry / budget / sandbox / audit / rollback / harness — six modules. Three key API design decisions: execute() as unified entry point, refund() on IRREVERSIBLE interception, and approve_and_execute() as the human-approval channel. Validated by LangGraph integration examples and 45/45 tests.
Agent Series (19): Harness Engineering — Complete 8-Layer Framework
From the five-element intro to the full 8-layer framework: Minimal Footprint, Action Registry, Permission Budget, Execution Sandbox, Human Checkpoint, Immutable Audit Log, Rollback Coordinator, and Threat Model. Four adversarial scenarios expose three counter-intuitive findings: tool-scope limits are soft defenses, budget-before-approval is a design trap, and injection detection is not injection prevention.
Agent Series (17): Harness Engineering — Putting a Safety Harness on an Autonomous Agent
The more autonomous an agent becomes, the more it needs a controlled execution framework. This article uses real benchmarks to cover the five elements of Harness Engineering: Action Space (tool whitelist), Human Checkpoint (LangGraph interrupt), Execution Boundary (step cap), Audit Log, and Rollback. Three counter-intuitive findings included: a harness blocks actions, not model lies; execution boundaries must be graph-level; model capability is still the reliability floor.
Agent Series (15): Advanced Agent Memory — Short-term, Long-term, Compression
Agent memory isn't just store the chat history. This article breaks down three memory layers — short-term (MemorySaver for within-session context), long-term (cross-session user fact storage and injection), and history compression (token guard). Real benchmarks included, with a counter-intuitive finding: MemorySaver infrastructure works correctly, but the model's context-following ability determines whether it's actually used.
Agent Series (16): Tool Design — Five Principles for Getting the LLM to Use Your Tools Correctly
Tool design isn't for humans — it's for the LLM. Three comparison experiments cover the core principles: description quality affects tool selection (with a counter-intuitive prerequisite), raise-exception vs return-error-string behavior in real benchmarks, and fat omnibus tools vs fine-grained specialized tools. Five golden design rules included.
Agent Series (12): Agent Evaluation Framework — How Do You Know If Your Agent Is Actually Good?
Agents aren't regular functions — traditional software testing isn't enough. This article breaks down three evaluation dimensions with 13 runnable test cases and real benchmark results, including two counter-intuitive failures worth analyzing in depth.
Agent Series (13): Agent Security and Defense — Prompt Injection, Tool Abuse, and Data Leakage
An Agent's attack surface is three times larger than a plain LLM. Prompt injection can override role constraints, tool parameters can carry code injection, and outputs can accidentally leak sensitive data. Three runnable demos cover each attack vector, with real results comparing a naive vs hardened agent, a calculator allowlist in action, and a three-layer defense pipeline working together.
Agent Series (14): Agent Observability — Tracing Every Decision, Making the Black Box Transparent
An Agent's decision process is opaque by default. Why did it call three tools? Where did the 6-second latency go? How do you reproduce a production failure? This article implements three observability patterns with LangChain BaseCallbackHandler — live trace, latency timeline, and JSON audit log. Real benchmarks: LLM is 100% of wall time; tools are 2ms.