Topic

Context Engineering

All digests tagged Context Engineering

How To Build A Harness With Jev | A LangChain x TypeSafe Conversation thumbnail

· 48:04

How To Build A Harness With Jev | A LangChain x TypeSafe Conversation

This conversation introduces Jev, a novel System 1 model from TypeSafe AI, designed for fast, low-latency, and cost-effective decision-making. Unlike traditional LLMs, Jev does not generate text; instead, it makes structured decisions based on well-scoped questions and type-safe schemas. For build engineers, the primary focus is integrating Jev into agent harnesses (using frameworks like LangChain) to enhance reliability, manage risk (e.g., safety classification), and optimize resource usage (e.g., model routing) within the agent development lifecycle.

Key takeaways

  1. Jev is a System 1 Model, not a Generative LLM 5:23

    Jev is fundamentally different from LLMs; it does not generate text or images. It is designed to make fast, intuitive decisions from specific, well-scoped questions using type-safe schemas. This aligns with System 1 thinking (quick determinations), contrasting with System 2 thinking (multi-step reasoning, often associated with LLMs and code).

  2. Three Core Question Types for Structured Decisions 20:13

    Jev supports three decision types: **Choice** (selecting one option from a list, analogous to a classifier); **Score** (rating a state on a single, semantically defined axis, e.g., 0 to 2 for frustration); and **Noul** (a simple True/False or binary check). Questions must be broken down to the point they cannot be broken down further.

  3. Integrating Jev into Agent Middleware 32:37

    Jev can be integrated into agent harnesses as middleware to solve critical problems: **Safety Classification** (e.g., determining if a tool call is destructive and requires explicit intent) and **Model Routing** (selecting the optimal model—fast vs. in-depth—for a given task). This is significantly cheaper and faster than using heavy LLMs for every decision point.

  4. Context Engineering and Observability Best Practices

    When using Jev, it is crucial to minimize the state input to only what is strictly necessary for the determination. Furthermore, building auditability into the system and utilizing platforms like LangSmith for observability and evaluation (Evals) is highly recommended.

Watch on YouTube Full article

Dexter Horthy: Why We Stopped Trusting AI to Write the Plan thumbnail

· 56:12

Dexter Horthy: Why We Stopped Trusting AI to Write the Plan

The discussion explores the shift in software development from writing code to managing 'software factories' powered by AI agents. The central thesis is that while AI agents can automate much of the implementation, the primary value shifts to defining and codifying *intent* (specs) and *preferences* (taste). The speaker argues that the process of continuous improvement—building the factory itself—is more critical than the act of reviewing individual code pull requests. Human review, therefore, evolves from checking syntax to verifying high-level architectural intent and system constraints.

Key takeaways

  1. The Spec is the New Code 3:44

    The industry trend is moving toward treating specifications (specs) as the primary, verifiable, and executable artifact. This approach aims to capture the full intent of a feature, which can then be compiled into code, rather than relying on the code itself as the source of truth.

  2. Context Engineering and the 'Dumb Zone' 10:03

    Context engineering is crucial for effective agentic development. Early models exhibited a 'dumb zone' where performance degraded significantly when the context window exceeded a certain token count (e.g., 100,000 tokens), emphasizing the need for intentional context management.

  3. The Value of the Software Factory 28:23

    A 'software factory' is a system that automates the entire development lifecycle (planning, building, reviewing, rolling out). The goal is to shift focus from fixing individual bugs to continuously improving the factory's processes and skills, thereby increasing overall velocity.

  4. The Persistence of Human Review 53:52

    While AI is powerful, the speaker asserts that there will always be 'alpha in reviewing something.' Human review will shift from checking code correctness to verifying high-level architectural decisions, business logic, and unique organizational 'taste' that models cannot inherently replicate.

Watch on YouTube Full article

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked thumbnail

· 14:09

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked

AI agents require more than just access to information; they need a 'context engine' to achieve true understanding of a company's operations, business logic, and historical decisions. The talk details how agents fail when they lack deep, organizational context, leading to wasted tokens and time. The solution involves building a context engine that ingests data from disparate sources (e.g., ticketing systems, code repos) and provides structured, conflict-resolved context to the model in a token-optimized manner.

Key takeaways

  1. The Context Gap

    AI-generated code must feel like it was written by a long-term team member, which requires deep operational context that current agents lack. This gap compounds as agents scale from simple tab completion to background processes.

  2. Failure Modes of Context 7:00

    Common approaches like the 'curated context trap' (where documentation rots) and the 'MCP plateau' (where agents suffer from satisfaction of search bias) fail because access to information is not the same as understanding it.

  3. The Role of the Context Engine 9:12

    A proper context engine must perform conflict resolution (e.g., resolving conflicting architecture diagrams vs. Slack messages), respect permissions (OAuth/SSO), and deliver context in a token-optimized way.

  4. Efficiency Gains 13:00

    Implementing a context engine can lead to significant efficiency gains, demonstrated by a reduction from 21 million to 10.8 million tokens and a two-hour reduction in wall-clock time for the same task.

Watch on YouTube Full article

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn thumbnail

· 20:25

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn

LinkedIn addressed the challenge of coding agents (LLMs) lacking context within massive, proprietary enterprise codebases. The solution involves 'contextual agent playbooks and tools' managed by an internal MCP (Model Context Platform) server. Instead of feeding all tools into the context, the system uses three meta-tools—Search, Get Schema, and Execute—to scale to thousands of tools and playbooks. Playbooks provide self-contained, structured instructions, enabling agents to perform complex, multi-step tasks reliably, and incorporating a self-improving loop where agents update stale documentation.

Key takeaways

  1. Focus on Reliability and Quality from Day One 20:00

    The system's success was predicated on prioritizing quality and reliability over mere productivity, ensuring the infrastructure does not degrade as the organization scales its use of AI agents.

  2. Build Dedicated Infrastructure for Agents 20:10

    In a large enterprise, simply providing the latest AI models and tools is insufficient; a dedicated, robust infrastructure is required to manage and guide agent operations within the internal system context.

Watch on YouTube Full article

850 PRs a Week: How Tessl Runs a Software Factory thumbnail

· 51:18

850 PRs a Week: How Tessl Runs a Software Factory

The video outlines the concept of a 'Software Factory'—a modern development paradigm where most work is managed by self-improving AI agents. This factory model progresses from defining foundational standards (Skills) to creating automated, iterative workflows (Loops), culminating in full automation. Key insights emphasize that success requires prioritizing context engineering and standardization over raw speed, as the primary gains are increased code quality and functional fungibility across teams.

Key takeaways

  1. The Factory's True Gains 11:57

    Increased capacity does not solely lead to feature velocity; two major benefits observed are an increase in overall code quality (e.g., fixing consistency, copy, and brand voice) and improved fungibility, allowing non-engineering teams (like GTM) to make high-leverage changes without waiting on support.

  2. Context Precedes Automation 13:56

    The core principle is that before automating a process, one must first define 'what correct looks like.' This context definition serves as the manual for operating the company and is critical for building resilient, scalable agents.

  3. Skills $\rightarrow$ Loops $\rightarrow$ Factory 6:10

    The factory model is a continuum: Skills are defined units of work or policies; Loops are automated skills that improve with each run (compounding gains); and the Factory is the system where most development effort shifts to maintaining and improving these loops.

  4. Enforcing Standards: Verifiers and Evals 27:20

    To ensure quality at scale, systems must implement verifiers (generating LLM-judge tools from skills) and evals. These mechanisms enforce standards in CI/CD pipelines, moving code review checks 'left' into the development process.

Watch on YouTube Full article

Cisco & Stanford on Why Skills Are the New Code thumbnail

· 9:44

Cisco & Stanford on Why Skills Are the New Code

The industry is shifting from viewing software development around explicit code and implementation toward one centered on high-level intent and 'skills.' This paradigm requires a layered agent stack (models, tools, context, harnesses) that must be managed rigorously. Experts highlight that skill sprawl leads to failure through overlap, drift, and lack of activation visibility. Crucially, the consensus is that achieving business value relies less on deploying increasingly powerful frontier models and more on sophisticated context engineering and centralized management of skills.

Key takeaways

  1. Skills as the New Code Paradigm 0:14

    Software development is transforming from revolving around code/implementation to revolving around intent and instructions. Skills must be treated as first-class citizens, not just configuration files (Guy Podjarny).

  2. Three Failure Modes of Skill Sprawl 3:29

    Skill sprawl negatively impacts teams through: 1) Overlap (multiple isolated implementations achieving the same outcome); 2) Drift (teams using outdated versions of skills); and 3) Lack of Activation (no visibility into whether a skill is actually being used by agents or humans).

  3. Context Engineering Beats Model Size 6:59

    For achieving business value, smarter context engineering is more critical than deploying the most advanced model. Mid-tier models (e.g., Sonnet, GPT medium reasoning) are often sufficient when provided with proper context and structured skills.

  4. Instruction Following Leakage 8:48

    Empirical testing involving 500 skills across 1,000 tasks revealed that over half (55%) of the time, models followed a skill's instructions even when the skill was not loaded. This suggests valuable information is already encoded in model weights.

Watch on YouTube Full article

Anthropic, OpenAI & Thoughtworks on Context Engineering thumbnail

· 10:08

Anthropic, OpenAI & Thoughtworks on Context Engineering

The core challenge in deploying AI agents is shifting from model intelligence to context engineering. Speakers from Anthropic, OpenAI, Thoughtworks, and Tessl argue that the surrounding context—including organizational knowledge, structured guides, and robust feedback loops—is the primary multiplier for agent capability. Key technical concepts include defining new constraints (human time, attention, context window), building specialized harnesses using computational tools like codemods and static analysis, and establishing a Context Development Lifecycle (CDLC) that runs parallel to the traditional Software Development Lifecycle (SDLC).

Key takeaways

  1. Context Engineering Multiplies Intelligence 0:24

    Model intelligence alone is insufficient for durable, scalable products. Context engineering provides the necessary domain-specific knowledge required for agents to succeed within an organization.

  2. Remaining Software Constraints 5:02

    Most traditional software engineering constraints are obsolete. The three remaining foundational limits when using human-agent teams are: human time (the most scarce resource), human/model attention, and the context window size.

  3. Agent Harness Architecture 8:41

    A coding agent harness requires two components: 'guides' that proactively point the agent forward, and 'sensors' that provide immediate feedback for self-correction (e.g., static analysis, logs).

  4. The Context Development Lifecycle (CDLC)

    Humans must own the CDLC while agents handle the SDLC. This involves generating context, evaluating agent performance via runtime observability, and optimizing skills in a continuous loop.

Watch on YouTube Full article

Inside DeepWiki: How Cognition Builds Wikis for Devin at Scale thumbnail

· 17:12

Inside DeepWiki: How Cognition Builds Wikis for Devin at Scale

Jacob Teo details DeepWiki, an auto-generated codebase documentation product used as a context layer for agents like Devin. The presentation covers how DeepWiki scaled from internal tools to indexing 1.4 million repositories. Key technical advancements include evolving the wiki algorithm from a heavily orchestrated v1 to a more agentic v2, which improves robustness at massive scale. Furthermore, he outlines four principles of context engineering—Primary Sources, Context-Poisoning avoidance, Path Compression, and Unknown Unknowns—to guide future codebase intelligence systems.

Key takeaways

  1. DeepWiki's Evolution (v1 to v2) 12:28

    The wiki algorithm shifted from being highly orchestration-led (relying on tight control over model calls) to an agentic core (V2). This shift allows the system to adapt to code base abnormalities by enabling the agent to call tools for extra scaffolding, making it more robust as models improve. (7:48)

  2. Context Engineering Principles

    When building context for agents, Cognition emphasizes four principles: ensuring primary sources are trusted ground truth; avoiding context-poisoning by only providing correct information; using Path Compression to skip obvious steps and save tokens/cost; and leveraging Unknown Unknowns—providing hints the agent wouldn't find on its own. (12:40)

  3. Codebase Graphing for Scale 10:07

    To handle large enterprises with massive codebases, DeepWiki uses heuristics incorporating directory structure, symbol graphs, Git history, and runtime data to quantify file connections. This process creates a codebase graph that informs the Table of Contents (TOC), which is critical because poor TOC generation leads to a bad wiki regardless of individual page quality. (6:07)

Watch on YouTube Full article

Context Engineering in 2026 — Louis-François Bouchard, Omar Solano & Samridhi Vaid, Towards AI thumbnail

· 1:03:26

Context Engineering in 2026 — Louis-François Bouchard, Omar Solano & Samridhi Vaid, Towards AI

This talk provides a deep dive into context engineering for large language model (LLM) agents, focusing on optimizing performance and cost in real-world applications like an AI tutor. The core finding is that compaction techniques (like summarization) are often detrimental because they invalidate the prompt cache, forcing the system to pay full price for every token. For optimal recall and cost efficiency, retaining the full history—especially when leveraging advanced caching mechanisms—is superior to aggressive context reduction.

Key takeaways

  1. Compaction is a potential trap due to Prompt Caching 22:06

    When using prompt caching (which can make cached tokens up to 50 times cheaper), any transformation or summarization of the context invalidates the cache, forcing full-price token usage. Compaction must shrink the context by more than 50 times just to pay for itself.

  2. Full History Retention Wins on Recall 33:33

    Experiments showed that leaving the full history untouched (the 'full history' preset) provided the best memory recall and overall performance, even though it was the most expensive option. Aggressive compaction techniques significantly degraded factual retrieval.

  3. Hybrid Search is Superior for Retrieval 22:48

    For knowledge base browsing, a hybrid search combining semantic similarity (embedding model) with keyword search (BM25) is necessary to achieve high recall. Pure dense retrieval failed when facts were buried at large context sizes (e.g., 400k tokens), while BM25 maintained 100% accuracy.

Watch on YouTube Full article

The Rise of CaaS: Context-as-a-Service for Agentic AI — Omer Primor, Bright Data thumbnail

· 22:20

The Rise of CaaS: Context-as-a-Service for Agentic AI — Omer Primor, Bright Data

The video analyzes the shift from viewing web data as a simple source of information to treating it as dynamic 'context' for agentic AI. The speaker argues that Context-as-a-Service (CaaS) vendors are emerging to provide structured knowledge graphs, acting as vertical search engines. Critically, he emphasizes that at scale, the cost killer is not initial volume but the *frequency* of repeated queries. For persistent knowledge work, owning and building a custom data pipeline—even if time-consuming—can eventually become more cost-effective than continually renting context from third-party vendors.

Key takeaways

  1. Context Decay: Data is never a snapshot 0:02

    Web data decays quickly (e.g., social content < 1 day; news/finance ~30 days). Therefore, extracting context must be treated as an ongoing process, not a one-time effort [2:43].

  2. The Rise of CaaS for Agents 0:06

    AI agents require structured knowledge beyond what general search provides. CaaS vendors address this by developing and indexing specialized knowledge graphs (vertical search) across multiple data sources, enabling deep reasoning [6:32].

  3. Frequency is the Cost Killer at Scale 0:12

    When performing repeated due diligence or market research, every query costs money, even if nothing has changed. This recurring cost (frequency) eventually surpasses the initial setup cost of building an owned pipeline [12:32].

  4. The Tipping Point for Ownership 0:15

    There is a tipping point where the cumulative cost of repeated context queries makes it economically viable to build and own the data retrieval pipeline in-house, potentially bypassing middleman costs [15:22].

Watch on YouTube Full article

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026 thumbnail

· 15:42

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026

The talk demystifies 'agentic coding' by establishing a fundamental baseline for understanding AI-assisted development tools. The core concept is that these systems rely on three components: the models (the brain), the harnesses (the ability to act), and the tools (specific functions). Speakers emphasize that while the ecosystem moves rapidly, understanding this architecture—especially the feedback loop where the harness executes actions based on model intentions—is crucial for practitioners. A key recommendation is maintaining control by favoring open-source, customizable systems over locked-down, proprietary solutions.

Key takeaways

  1. The Three Pillars of AI Coding Tools 4:00

    AI coding tools fundamentally consist of three parts: the models (e.g., GPTs from OpenAI, Claude from Anthropic), the harnesses, and the tools. The model is the 'brain,' but the harness allows it to perform actions beyond text generation.

  2. Understanding Agent Functionality 5:10

    Agents operate using a combination of a configurable system prompt (initial instructions) and defined tools. The model generates an *intention* (text), which the harness executes (e.g., reading files, running terminal commands). The output is then fed back into the model, creating a critical feedback loop.

  3. The Importance of Openness and Control 11:10

    While proprietary tools (like Cloud Code) are powerful, speakers caution against losing control. The ability to customize the harness is vital for a healthy ecosystem; open-source solutions allow introspection and customization.

Watch on YouTube Full article

What Is Context Engineering? Why It Matters for AI Agents thumbnail

· 9:57

What Is Context Engineering? Why It Matters for AI Agents

The industry is shifting focus from prompt engineering—which only addresses instruction phrasing—to Context Engineering. Context Engineering is defined as the deliberate practice of structuring and optimizing all information provided to an LLM or AI agent to ensure accurate and reliable outputs. For complex agents that reason across multiple steps, context management is critical because performance can degrade (context rot) when too much irrelevant or poorly structured data is included.

Key takeaways

  1. Context Engineering vs. Prompt Engineering

    Prompt engineering focuses solely on phrasing instructions for an LLM. Context engineering, however, addresses the entire information environment provided to the model, recognizing that prompt engineering is merely one component of context.

  2. The Danger of Over-Context 3:33

    More context does not guarantee better performance. Providing too much irrelevant or poorly structured data can lead to 'context rot,' resulting in worse reasoning and increased hallucinations.

  3. Core Components of Context 4:10

    Context includes the system prompt, user query, retrieved documents (e.g., from a vector database), interaction history, tool outputs, and API results.

Watch on YouTube Full article

Every Harness Will Become A Claw — Sam Bhagwat, Mastra thumbnail

· 15:36

Every Harness Will Become A Claw — Sam Bhagwat, Mastra

The evolution of AI agents is moving from localized 'Harnesses'—tools used for coding and task execution—to persistent, always-on services called 'Claws.' This transition involves imbuing agents with initiative, external connectivity (like a heartbeat), and continual learning capabilities. The speaker proposes Steinberger's law: every harness will expand until it becomes a Claw, driven by the desire for powerful, integrated developer experiences.

Key takeaways

  1. Harnesses are evolving into Claws 1:42

    The next generation of agents moves beyond local execution to become always-on services that listen to external events (e.g., Slack, mobile apps) and maintain a persistent 'heartbeat.'

  2. Agentic Spectrum Advancement 0:49

    Agents are advancing through stages: Agent $ ightarrow$ Harness $ ightarrow$ Claw. Key technical advancements include durability, doggedness, planning mode, and parallel subagents.

  3. Cloud vs. Local Architecture 1:48

    The shift from local harnesses to cloud harnesses provides greater parallelism and resources but necessitates a different distributed system architecture.

Watch on YouTube Full article