Context Engineering

# Context Engineering

Part of [Agent Skills™](https://github.com/itallstartedwithaidea/agent-skills) by [googleadsagent.ai™](https://googleadsagent.ai)

## Description

Context Engineering is the discipline of maximizing agent output quality while minimizing token expenditure. In a world where every token carries cost and latency implications, the ability to surgically curate what enters an agent's context window separates production-grade systems from expensive toys. This skill codifies the techniques pioneered across the [googleadsagent.ai™](https://googleadsagent.ai) platform, where Buddy™ routinely operates within 200k-token windows while maintaining domain-expert-level accuracy.

The core insight is that context is not merely "what you send to the model" — it is working memory, and it must be engineered with the same rigor as any other system resource. Information density optimization, structured loading sequences, and progressive disclosure patterns ensure the agent receives precisely the right information at precisely the right moment. Poorly engineered context leads to hallucination, instruction drift, and ballooning costs.

This skill teaches agents to treat context as a finite, managed resource: measure it, compress it, prioritize it, and reclaim it. The techniques here apply universally across Claude Code, Cursor, Codex, and Gemini harnesses.

## Use When

- Agent responses degrade in quality as conversations grow longer
- Token costs are exceeding budget thresholds for production workloads
- The agent needs to reason over large codebases without losing focus
- You need to inject domain knowledge without consuming the entire context window
- Multi-step workflows require carrying forward only essential state between steps
- The agent is hallucinating due to context window saturation or dilution

## How It Works

```mermaid
graph TD
    A[Raw Context Sources] --> B[Relevance Scoring]
    B --> C{Score > Threshold?}
    C -->|Yes| D[Compression Engine]
    C -->|No| E[Context Archive]
    D --> F[Priority Queue]
    F --> G[Token Budget Allocator]
    G --> H[Context Window Assembly]
    H --> I[Agent Execution]
    I --> J[Context Reclamation]
    J --> K{Session Active?}
    K -->|Yes| B
    K -->|No| L[Session Summary → Memory]
```

The context lifecycle begins with raw sources — files, previous messages, tool outputs, knowledge bases — flowing through a relevance scoring pass. Items scoring below the threshold are archived rather than discarded, available for retrieval if needed. High-relevance items enter a compression engine that reduces token footprint while preserving semantic content. A priority queue orders compressed items by recency, importance, and task relevance. The token budget allocator enforces hard limits, ensuring the assembled context window never exceeds the target budget. After agent execution, context reclamation identifies items that are no longer needed for subsequent turns.

## Implementation

**Token Budget Enforcement:**

```javascript
class ContextBudget {
  constructor(maxTokens = 180000) {
    this.maxTokens = maxTokens;
    this.reservedForOutput = 20000;
    this.reservedForSystem = 5000;
    this.available = maxTokens - this.reservedForOutput - this.reservedForSystem;
    this.allocations = new Map();
  }

  allocate(category, tokens) {
    const currentUsage = this.currentUsage();
    if (currentUsage + tokens > this.available) {
      return this.evictAndAllocate(category, tokens);
    }
    this.allocations.set(category, (this.allocations.get(category) || 0) + tokens);
    return true;
  }

  evictAndAllocate(category, needed) {
    const sorted = [...this.allocations.entries()]
      .sort((a, b) => a[1] - b[1]);
    for (const [cat, tokens] of sorted) {
      if (cat === category) continue;
      this.allocations.delete