# How the Site Skills Learning System in Ego-Lite Accumulates Knowledge Across Tasks

> Discover how Ego-Lite's site skills learning system accumulates knowledge by persisting reusable skill packs and merging domain entries for a unified context. Learn more!

- Repository: [CitroLabs/ego-lite](https://github.com/citrolabs/ego-lite)
- Tags: deep-dive
- Published: 2026-08-04

---

**Ego-Lite's site skills learning system accumulates knowledge by persisting reusable skill packs to disk and merging all matching domain entries into a unified context object whenever an agent queries the site façade.**

The **site skills learning system** in the `citrolabs/ego-lite` repository provides a cumulative, disk-backed layer that allows AI agents to retain and reuse domain-specific knowledge across multiple tasks. Unlike ephemeral session data, these learned skills persist as structured packs under the `skills/ego-browser/learnings` directory, enabling automatic knowledge aggregation every time an agent interacts with a website.

## What Are Site Skills in Ego-Lite?

Site skills are reusable knowledge packs that encapsulate expertise for specific web domains. Each pack resides in its own subdirectory (e.g., `skills/ego-browser/learnings/x-com/`) and is defined by a [`manifest.json`](https://github.com/citrolabs/ego-lite/blob/main/manifest.json) file that declares four key components:

- **Domains** – Host patterns (e.g., `["x.com", "*.x.com"]`) that determine which URLs trigger the skill
- **Notes** – Markdown files containing human-readable knowledge and instructions
- **Node tools** – Server-side functions callable from agent scripts
- **Browser tools** – JavaScript snippets that execute within the page context

This structure allows the **site skills learning system** to treat knowledge as modular, composable units that can be developed independently and combined at runtime.

## How Knowledge Accumulation Works

The accumulation process follows a three-stage pipeline implemented in the `ego-browser` package. When an agent calls any `site.*` helper, the runtime aggregates all applicable skill packs into a single coherent context.

### Step 1: Domain Matching with siteSkillsForUrl

The system first identifies which skill packs apply to the current URL using the `siteSkillsForUrl(url)` function defined in [`src/helpers.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/helpers.ts) at line 64. This helper walks the `learnings` directory and returns every entry whose `domains` array matches the supplied URL pattern.

Because the matching logic supports overlapping patterns, multiple skill packs can contribute to the same domain simultaneously. For example, both a generic `google` pack and a specialized `google-ads` pack can match `https://ads.google.com`, allowing their knowledge to accumulate.

### Step 2: Context Loading with learnContext

Once matching entries are identified, the `learnContext(url?)` function (defined at line 513 of [`src/helpers.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/helpers.ts)) delegates to `loadLearnedContext` in [`src/learning/index.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/learning/index.ts) at line 46. This loader performs the actual accumulation:

- **Reads every note file** listed in `entry.notes`, storing the raw markdown content as `knowledgeNotes`
- **Collects tool signatures** from both `nodeTools` and `browserTools` arrays, building a unified list of `LearnedToolSignature` objects (`toolSignatures`)

### Step 3: Merged Knowledge Object

The `learnContext` function returns a single accumulated object containing all aggregated data:

```typescript
{
  exists: true,
  siteId: "<primary-site-id>",
  siteName: "<human-readable-name>",
  domain: "<hostname>",
  knowledge: [ …notes from all matching packs… ],
  tools: [ …tool signatures from all matching packs… ]
}

```

Because the helper aggregates **all** matching entries, knowledge and tools accumulate automatically as more skill packs are added to the repository or created at runtime.

## Cross-Task Persistence Mechanism

The **site skills learning system** maintains knowledge across different tasks by storing learned data on disk within the agent workspace (`state.agentWorkspace()`). Each task space can invoke the same `site.learnContext()` helper, which re-loads the current set of notes and tool definitions from the persistent skill directory.

This disk-backed approach ensures that:
- Knowledge survives individual task sessions
- Multiple agents or task runs share the same accumulated expertise
- Updates to skill packs (adding new notes or tools) are immediately available to subsequent tasks without requiring system restarts

## Working with Accumulated Knowledge in Agent Scripts

Agent scripts interact with the accumulated knowledge through the `site` façade. Here are practical examples demonstrating how to query and utilize the learned context:

Get the full learned context for the current page:

```typescript
const ctx = await site.learnContext();   // uses current page URL
console.log('Notes:', ctx.knowledge.map(k => k.fileName));
console.log('Tools:', ctx.tools.map(t => t.toolName));

```

List available site-skill tools for a specific URL:

```typescript
const tools = await site.skills('https://x.com/home');
console.log('Available tools:', tools);

```

Run a Node-side site tool defined in the X-Com skill pack:

```typescript
const timeline = await site.runTool('x-com', 'get_timeline_posts', { maxPosts: 20 });
console.log('Timeline posts:', timeline);

```

Execute a browser-side tool that extracts data from the active element:

```typescript
const post = await site.runBrowserTool('x-com', 'post_from_active_element');
console.log('Active post data:', post);

```

## Summary

- **Site skills** are reusable packs stored under `skills/ego-browser/learnings/`, defined by [`manifest.json`](https://github.com/citrolabs/ego-lite/blob/main/manifest.json) files containing domains, notes, and tools.
- **Knowledge accumulation** occurs through `siteSkillsForUrl()` matching followed by `loadLearnedContext()` aggregation in [`src/learning/index.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/learning/index.ts).
- **Cross-task persistence** is achieved by storing skill packs on disk within `state.agentWorkspace()`, making accumulated knowledge available to all subsequent agent tasks.
- **Multiple packs** can target the same domain, allowing specialized skills to layer atop generic ones.
- **Runtime access** is provided via the `site.learnContext()`, `site.runTool()`, and `site.runBrowserTool()` helpers defined in [`src/helpers.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/helpers.ts).

## Frequently Asked Questions

### How does Ego-Lite match URLs to site skills?

Ego-Lite uses the `siteSkillsForUrl(url)` function in [`src/helpers.ts`](https://github.com/citrolabs/ego-lite/blob/main/src/helpers.ts) (line 64) to compare the supplied URL against the `domains` array in each skill pack's [`manifest.json`](https://github.com/citrolabs/ego-lite/blob/main/manifest.json). The function supports wildcard patterns and returns all matching entries, enabling multiple skills to apply to a single domain.

### Where is accumulated knowledge stored between tasks?

Accumulated knowledge persists on disk under the path returned by `state.agentWorkspace()`, specifically within the `skills/ego-browser/learnings/` directory. Because the storage is filesystem-based rather than memory-based, learned skills survive task completion and remain available for future agent sessions.

### Can multiple skill packs apply to the same domain?

Yes. The accumulation system is designed to merge all matching skill packs. For instance, both a generic `google` pack and a specialized `google-ads` pack can match `https://ads.google.com`. The `loadLearnedContext` function combines their notes and tools into a single context object, allowing specialized knowledge to extend general capabilities.

### What is the difference between node tools and browser tools?

**Node tools** are server-side functions defined in the skill pack's [`manifest.json`](https://github.com/citrolabs/ego-lite/blob/main/manifest.json) that execute in the Node.js runtime environment, suitable for API calls or data processing. **Browser tools** are JavaScript code snippets that run inside the target page's browser context, enabling direct DOM manipulation and extraction. Agent scripts invoke node tools via `site.runTool()` and browser tools via `site.runBrowserTool()`.