Context Enhancement

Context Enhancement

Learn from user answers to detect patterns and build persistent context that reduces repeated questions.

FREE. No charge per call. Requires Claw0x API key for authentication.

What It Does

Context Enhancement analyzes user answers to detect patterns and build a persistent context layer that:

• Remembers user preferences (language, code style, deployment strategy)
• Detects patterns in responses (e.g., "always use TypeScript", "deploy to staging first")
• Generates rules based on detected patterns
• Reduces repeated questions by learning from past interactions

Prerequisites

IMPORTANT: This is the server-side version that runs through Claw0x Gateway. An API key is required for authentication, rate limiting, and usage tracking.

1. Sign up at claw0x.com
2. Create API key in Dashboard
3. Set environment variable:

   export CLAW0X_API_KEY="ck_live_..."
   

Note: For local use without API key, install via ClawHub: openclaw skills install context-enhancement

Pricing

FREE. No charge per call.

• Requires Claw0x API key for authentication
• No usage charges (price_per_call = 0)
• Unlimited calls
• Used for rate limiting and usage tracking

Use Cases

Scenario 1: Code Style Preferences

Problem: Agent asks "Use single or double quotes?" every time
Solution: After first answer, Context Enhancement detects pattern and remembers preference
Result: Agent automatically uses preferred style without asking

Scenario 2: Deployment Strategy

Problem: Agent doesn't remember user's deployment workflow
Solution: Learns from answers like "Always deploy to staging first"
Result: Agent follows learned deployment strategy automatically

Scenario 3: Language Preferences

Problem: Agent asks "TypeScript or JavaScript?" for every new file
Solution: Detects language preference pattern from past answers
Result: Agent defaults to preferred language

Scenario 4: Team Context Sharing

Problem: Each team member has to teach the agent their preferences
Solution: Context can be shared across team members
Result: Consistent behavior across team

Quick Reference

5-Minute Quickstart

Step 1: Get API Key (30 seconds)

Sign up at claw0x.com → Dashboard → Create API Key

Step 2: Set Environment Variable (30 seconds)

export CLAW0X_API_KEY="ck_live_..."

Step 3: Analyze First Answer (1 minute)

curl -X POST https://api.claw0x.com/v1/call \
  -H "Authorization: Bearer $CLAW0X_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "skill": "context-enhancement",
    "input": {
      "action": "analyze-answer",
      "question": "Use TypeScript or JavaScript?",
      "context": "Creating auth endpoint",
      "answer": "TypeScript",
      "user_id": "user_123"
    }
  }'

Step 4: See Pattern Detection (instant)

{
  "pattern_detected": "language_preference",
  "confidence": 0.95,
  "suggested_rule": "User prefers TypeScript for new code",
  "context_update": {
    "preferences.language": "TypeScript",
    "preferences.use_cases": ["Creating auth endpoint"]
  },
  "_meta": {
    "skill": "context-enhancement",
    "latency_ms": 15
  }
}

Step 5: Get Context (instant)

curl -X POST https://api.claw0x.com/v1/call \
  -H "Authorization: Bearer $CLAW0X_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "skill": "context-enhancement",
    "input": {
      "action": "get-context",
      "user_id": "user_123"
    }
  }'

Real-World Use Cases

Scenario 1: Onboarding New Agent

Problem: New agent doesn't know user preferences
Solution: Use Context Enhancement to learn from first interactions
Example:

// First interaction
await claw0x.call('context-enhancement', {
  action: 'analyze-answer',
  question: 'Preferred code style?',
  answer: 'Single quotes, no semicolons',
  user_id: 'user_123'
});

// Later interactions - agent checks context
const context = await claw0x.call('context-enhancement', {
  action: 'get-context',
  user_id: 'user_123',
  scope: 'preferences'
});
// context.preferences.code_style.quotes === 'single'

Scenario 2: Reducing Repeated Questions

Problem: Agent asks same questions repeatedly
Solution: Detect patterns and generate rules
Example:

// After 3 similar answers, pattern is detected
await claw0x.call('context-enhancement', {
  action: 'detect-patterns',
  user_id: 'user_123'
});
// Returns: [
//   {
//     pattern: 'deployment_strategy',
//     frequency: 3,
//     confidence: 0.98,
//     suggested_rule: 'Always deploy to staging first'
//   }
// ]

Scenario 3: Team Context Sharing

Problem: Each team member has different preferences
Solution: Use team-level context
Example:

// Team lead sets preferences
await claw0x.call('context-enhancement', {
  action: 'update-context',
  user_id: 'team_acme',
  updates: {
    'preferences.language': 'TypeScript',
    'preferences.deployment': 'staging-first',
    'preferences.code_style.quotes': 'single'
  }
});

// All team members inherit team context
const teamContext = await claw0x.call('context-enhancement', {
  action: 'get-context',
  user_id: 'team_acme'
});

Scenario 4: Progressive Learning

Problem: Agent needs to learn complex workflows
Solution: Analyze multiple interactions to detect patterns
Example:

// Interaction 1
await claw0x.call('context-enhancement', {
  action: 'analyze-answer',
  question: 'Run tests before deploy?',
  answer: 'Yes, always',
  user_id: 'user_123'
});

// Interaction 2
await claw0x.call('context-enhancement', {
  action: 'analyze-answer',
  question: 'Deploy to staging first?',
  answer: 'Yes',
  user_id: 'user_123'
});

// Pattern detected: deployment_strategy
// Rule generated: "Run tests, then deploy to staging, then production"

Integration Recipes

OpenClaw Agent

import { Claw0xClient } from '@claw0x/sdk';

const claw0x = new Claw0xClient(process.env.CLAW0X_API_KEY);

agent.onQuestion(async (question, context, answer) => {
  // Analyze answer to detect patterns
  const result = await claw0x.call('context-enhancement', {
    action: 'analyze-answer',
    question,
    context,
    answer,
    user_id: agent.userId
  });
  
  if (result.pattern_detected) {
    console.log(`Pattern detected: ${result.pattern_detected}`);
    console.log(`Rule: ${result.suggested_rule}`);
  }
});

agent.beforeAction(async (action) => {
  // Check context before taking action
  const context = await claw0x.call('context-enhancement', {
    action: 'get-context',
    user_id: agent.userId,
    scope: 'preferences'
  });
  
  // Apply preferences to action
  if (context.preferences.language) {
    action.language = context.preferences.language;
  }
});

LangChain Agent

from claw0x import Claw0xClient

claw0x = Claw0xClient(api_key=os.environ['CLAW0X_API_KEY'])

def analyze_answer(question, context, answer, user_id):
    result = claw0x.call('context-enhancement', {
        'action': 'analyze-answer',
        'question': question,
        'context': context,
        'answer': answer,
        'user_id': user_id
    })
    
    if result['pattern_detected']:
        print(f"Pattern: {result['pattern_detected']}")
        print(f"Rule: {result['suggested_rule']}")
    
    return result

def get_user_context(user_id):
    return claw0x.call('context-enhancement', {
        'action': 'get-context',
        'user_id': user_id,
        'scope': 'all'
    })

Custom Agent

const axios = require('axios');

async function enhanceContext(question, answer, userId) {
  const response = await axios.post('https://api.claw0x.com/v1/call', {
    skill: 'context-enhancement',
    input: {
      action: 'analyze-answer',
      question,
      answer,
      user_id: userId
    }
  }, {
    headers: {
      'Authorization': `Bearer ${process.env.CLAW0X_API_KEY}`,
      'Content-Type': 'application/json'
    }
  });
  
  return response.data;
}

async function getUserPreferences(userId) {
  const response = await axios.post('https://api.claw0x.com/v1/call', {
    skill: 'context-enhancement',
    input: {
      action: 'get-context',
      user_id: userId,
      scope: 'preferences'
    }
  }, {
    headers: {
      'Authorization': `Bearer ${process.env.CLAW0X_API_KEY}`,
      'Content-Type': 'application/json'
    }
  });
  
  return response.data.context.preferences;
}

Workflow Diagram

User Answer
  ↓
Context Enhancement (analyze-answer)
  ↓
Pattern Detection
  ├─ Language Preference (confidence: 0.95)
  ├─ Deployment Strategy (confidence: 0.98)
  ├─ Code Style (confidence: 0.92)
  └─ Generic Preference (confidence: 0.7)
  ↓
Rule Generation
  ├─ "User prefers TypeScript"
  ├─ "Deploy to staging first"
  └─ "Use single quotes"
  ↓
Context Update
  ├─ preferences.language = "TypeScript"
  ├─ preferences.deployment = "staging-first"
  └─ preferences.code_style.quotes = "single"
  ↓
Agent Uses Context
  ├─ Checks preferences before asking
  ├─ Applies learned rules automatically
  └─ Reduces repeated questions

Why Use Via Claw0x?

• Unified infrastructure: One API key for all skills
• Agent-optimized: Built specifically for agent context management
• Production-ready: 99.9% uptime, <20ms latency
• Free: No usage charges (price_per_call = 0)
• Privacy: Context stored securely, isolated per user

Input Parameters

analyze-answer

• action: "analyze-answer" (required)
• question: Question that was asked (required)
• context: Context of the question (optional)
• answer: User's answer (required)
• user_id: User identifier (optional, defaults to "default")

get-context

• action: "get-context" (required)
• user_id: User identifier (optional)
• scope: "preferences" | "patterns" | "rules" | "all" (optional, defaults to "all")

update-context

• action: "update-context" (required)
• user_id: User identifier (optional)
• updates: Object with context updates (required)

detect-patterns

• action: "detect-patterns" (required)
• user_id: User identifier (optional)
• history_days: Number of days to analyze (optional, defaults to 30)

Output Format

analyze-answer

{
  "pattern_detected": "language_preference",
  "confidence": 0.95,
  "suggested_rule": "User prefers TypeScript for new code",
  "context_update": {
    "preferences.language": "TypeScript"
  },
  "_meta": {
    "skill": "context-enhancement",
    "latency_ms": 15
  }
}

get-context

{
  "context": {
    "preferences": {
      "language": "TypeScript",
      "deployment": "staging-first"
    },
    "patterns": [
      {
        "pattern": "language_preference",
        "confidence": 0.95,
        "examples": ["Creating auth endpoint"],
        "rule": "User prefers TypeScript"
      }
    ],
    "rules": [
      "User prefers TypeScript for new code",
      "Deploy to staging first"
    ]
  },
  "_meta": {
    "skill": "context-enhancement",
    "latency_ms": 10
  }
}

detect-patterns

{
  "patterns": [
    {
      "pattern": "language_preference",
      "frequency": 5,
      "confidence": 0.95,
      "suggested_rule": "User prefers TypeScript"
    },
    {
      "pattern": "deployment_strategy",
      "frequency": 3,
      "confidence": 0.98,
      "suggested_rule": "Deploy to staging first"
    }
  ],
  "_meta": {
    "skill": "context-enhancement",
    "latency_ms": 12
  }
}

Error Handling

Pattern Detection Types

Best Practices

1. Use consistent user_id: Same user_id across sessions to maintain context
2. Provide context: Include context field for better pattern detection
3. Check confidence: Only apply rules with confidence > 0.8
4. Review patterns: Periodically call detect-patterns to review learned patterns
5. Team context: Use team-level user_id for shared preferences

Limitations

• Context stored in memory (use database for production)
• Pattern detection is rule-based (not ML-based)
• Limited to predefined pattern types
• No automatic context expiration

Complementary Skills

• btw: Ask clarifying questions before context is built
• self-improving-agent: Learn from errors and corrections
• capability-evolver: Analyze and improve agent capabilities

About Claw0x

This skill is provided by Claw0x, the native skills layer for AI agents.

Explore more skills: claw0x.com/skills

GitHub: github.com/claw0x/context-enhancement