Observe.
Learn.
Organize.
Outgrow.

Oloo Agent is an open-source Chrome extension that turns any LLM into a browser agent. It follows the OLOO cycle -- observe the page, learn what matters, organize your knowledge, and outgrow the task. 41 automation tools. 8 AI providers. All data stays on your machine.

Your browser, your rules, your agent.

Install from GitHub Read the docs

// Oloo Agent

user: "Summarize this article and save key insights"

> Observing page...

✓ snapshot() — 4,210 tokens extracted

✓ get_text() — article content parsed

> Learning content...

✓ digest() — 3 key arguments identified

> Organizing knowledge...

✓ mind.save() — stored with tags and connections

agent: "Done. Saved 3 key insights to Mind with source links."

Oloo Agent is a desktop Chrome extension

It looks like you are on a mobile device. Oloo Agent requires Chrome on desktop. Leave your email and we will send you a reminder to install it later. One email, no spam.

Your email is used only to send this reminder. It is not added to a mailing list or shared with anyone.

MIT Licensed No Telemetry Local-First Data

GitHub Stars

The OLOO Way

The cognitive cycle behind every action

Every problem you solve follows the same pattern: you observe the situation, learn what matters, organize what you know, and outgrow the challenge. OLOO is that cycle -- encoded into software. The owl sees what others miss in the dark. Oloo Agent does the same in your browser. Each cycle makes the agent stronger, and each cycle makes you more capable.

O -- Observe

See the page as it truly is.

Oloo Agent starts by observing. Lens scans the current page -- extracting entities, relationships, and semantic structure. Not what you tell it to look for, but what is actually there. Most tools start with assumptions. Oloo starts with open eyes.

Lens

L -- Learn

Turn observation into understanding.

Seeing is not knowing. Digest transforms raw page content into structured knowledge -- articles decomposed by argument and evidence, products by features and pricing, research papers by methodology and conclusions. Information becomes knowledge only when you can use it.

Digest

O -- Organize

Connect the dots. Build the map.

Isolated knowledge is fragile. Mind stores what you have learned. Mark lets you annotate and tag. The knowledge graph connects entities across pages and sessions, surfacing patterns you would never see in a flat list of bookmarks. A library is not knowledge. A connected mind is.

Mind / Mark

O -- Outgrow

Grow beyond the task.

This is where knowing becomes doing. Skill workflows and 41 CDP tools execute real browser actions -- clicking, filling, navigating, extracting -- turning organized knowledge into automated capability. Outgrow does not mean winning once. It means growing to a level where the obstacle is no longer an obstacle. And every completion opens new observations, starting the cycle again.

Skill / CDP

Toolkit

Five building blocks. Infinite combinations.

Oloo Agent is not a single feature -- it is a toolkit of composable primitives. Each one is useful alone. Combined, they create automation that no chatbot can match.

composability.txt

Chat ──► Skills ──► Triggers ──► Hooks ──► Scripts
 │         │           │           │          │
 │         │           │           │          └─ Custom code
 │         │           │           └─ Lifecycle interception
 │         │           └─ Automatic activation
 │         └─ Packaged workflows with real actions
 └─ Natural language interface to everything
                        │
                  41 CDP Tools
              (the execution engine)

Chat

Talk to your browser. It talks back with actions.

Chat is the core interface. Ask a question about the current page, request a summary, or tell Oloo Agent to fill out a form -- all in natural language. Unlike chatbots that only return text, Oloo Agent can act on what it learns: clicking buttons, extracting data, navigating pages, all from the same conversation. Chat is where the OLOO cycle happens -- you observe together, the model learns, you organize insights, and the agent outgrows the task.

// Natural language → real actions

user: "Fill out this form with my info"

// Oloo Agent executes:

→ snapshot() // observe the form

→ fill("#name", "Andy")

→ fill("#email", "...")

→ click("#submit")

Skills

Reusable workflows that do real things.

A Skill is a workflow defined in a single Markdown file: system prompt, tool permissions, step-by-step instructions, and metadata. Skills are not prompt templates -- they are programs that execute real browser actions.

Because Skills are plain text files, they work with git, code review, pull requests, and text editors. Write a Skill like you write a README. Share them on GitHub. Install community Skills with a click.

post-to-x.skill.md

---
name: Post to X
description: Drafts and posts a thread to X/Twitter
author: oloo-community
tools:
  - get_text
  - navigate
  - click
  - fill
  - screenshot
triggers:
  - pattern: "*://dev.to/*"
---

# Instructions

1. Extract the main content from the current page
2. Draft a 3-tweet thread summarizing the key insights
3. Navigate to x.com/compose/post
4. Fill the compose box with the first tweet
5. Click the Post button
6. Repeat for the remaining tweets as replies

Triggers

Set it once. It runs forever.

Triggers watch for conditions and automatically run a Skill when they match. No manual activation needed.

URL pattern: fires when you open a matching page (e.g., every GitHub PR, every Hacker News thread)
Cron schedule: fires on a timer (e.g., every weekday at 9 AM)
Page event: fires on scroll depth, idle time, or tab switch

Summarize every article you open on Medium. Translate documentation on visit. Generate a morning briefing before you sit down. Triggers keep the OLOO cycle running without your intervention.

// Auto-fires on matching pages

trigger: *://medium.com/*

skill: "Summarize Article"

// Runs on schedule

trigger: cron "0 9 * * 1-5"

skill: "Morning Briefing"

Hooks

Intercept any moment in the agent's lifecycle.

Hooks let you inject logic at specific points in Oloo Agent's execution -- before a tool runs, after a message streams, when a conversation starts or ends. They are the control points that let developers reshape behavior without forking the codebase.

Log every tool call to an external analytics service
Add a confirmation step before any destructive action (delete, submit, post)
Inject context from Mind before every LLM call
Transform the agent's output format before it renders

// Lifecycle interception

before: tool_call

→ log to analytics

→ check permissions

after: message_stream

→ transform output

→ save to Mind

Scripts

Your code, inside the agent loop.

Scripts are user-defined JavaScript that executes within Oloo Agent's runtime. They bridge the gap between what the built-in tools provide and what your workflow actually needs.

Call an external API (Slack webhook, Notion API, custom backend)
Transform data between steps (parse CSV, format JSON, compute totals)
Query Mind for saved knowledge and inject it into the current Skill
Wire up integrations that no pre-built tool covers

Scripts give developers escape-hatch-level control without leaving the agent workflow.

// Your code, your integrations

const data = await mind.query("prices")

const diff = compare(data, today)

await fetch("https://slack.com/api/", {

body: formatAlert(diff)

})

In Practice

The real power is in the combination.

Most AI tools give you one thing: a chat box. Oloo Agent gives you building blocks. Each piece is useful on its own, but when you combine them, you get automation that no single feature could deliver. This is what separates a tool from a platform.

Scenario 1

Competitive price monitoring across 12 sites

scenario-1.workflow

Trigger (Cron: daily 7:00 AM)
  → Script: load competitor URL list from Mind (12 e-commerce sites)
    → Skill: "Price Monitor" -- for each site:
      → CDP Tools: navigate, wait for dynamic content to load
      → CDP Tools: extract product names, prices, stock status
      → Script: compare against yesterday's data in Mind, flag changes
    → Script: generate diff report, save to Mind
    → Script: POST summary to Slack webhook with price-drop alerts

Every morning, before anyone on your team is awake, Oloo Agent has visited 12 competitor sites, extracted live pricing (including JavaScript-rendered content that no API can reach), compared against historical data, and sent a Slack alert for every price change. Try doing that with a chatbot.

Scenario 2

Batch job applications with personalized cover letters

scenario-2.workflow

Trigger (URL: linkedin.com/jobs/* OR indeed.com/viewjob*)
  → Hook (before: start): load resume and past applications from Mind
    → Skill: "Job Applicant" -- for each listing:
      → CDP Tools: extract job title, requirements, company info
      → LLM: score fit against resume, skip if below threshold
      → LLM: draft cover letter matching company tone and role keywords
      → CDP Tools: click Apply, fill every field with real keyboard events
      → CDP Tools: upload resume PDF, paste cover letter
      → Hook (after: submit): save application record to Mind
      → Script: log to spreadsheet via Google Sheets API

Open a LinkedIn job listing. Oloo Agent reads the requirements, scores your fit, writes a cover letter that matches the company's tone, fills out the entire multi-page application form, uploads your resume, and logs it to your tracking spreadsheet. Do it once manually, then let the Trigger handle the next 50.

Scenario 3

Full-cycle content pipeline from research to publishing

scenario-3.workflow

Chat: "Research this topic and draft posts for my accounts"
  → Skill: "Content Pipeline":
    → CDP Tools: open 8 source URLs, extract key arguments from each
    → LLM: synthesize findings, identify 3 original angles
    → Hook (before: draft): load user's past posts from Mind to match voice
    → LLM: draft X thread (punchy, short), LinkedIn post (professional, longer),
           newsletter paragraph (conversational, detailed) -- each in the user's
           established writing style
    → CDP Tools: navigate to X, paste thread into compose, save as draft
    → CDP Tools: navigate to LinkedIn, paste post, save as draft
    → Script: send newsletter draft via Mailchimp API
    → Hook (after: complete): save all drafts to Mind with source links

Not "turn this page into a tweet." Instead: read 8 sources, synthesize original insights, adapt to 3 platforms in your voice, and place drafts where you can review them. The agent researches, thinks, writes, and distributes -- you just approve.

Scenario 4

Cross-platform data reconciliation

scenario-4.workflow

Trigger (Cron: weekly, Monday 6:00 AM)
  → Skill: "Data Reconciler":
    → CDP Tools: log in to Shopify admin, export last week's orders
    → CDP Tools: log in to QuickBooks, pull invoice records
    → CDP Tools: log in to shipping provider, pull tracking statuses
    → Script: parse and cross-reference all three datasets
    → LLM: identify mismatches -- orders without invoices,
           invoices without tracking, shipped but not marked complete
    → Script: generate reconciliation report with action items
    → CDP Tools: create a new Google Sheet, paste the report
    → Script: email the sheet link to the ops team

Three platforms. Three logins. Three data formats. One Skill reconciles them all weekly, surfaces every mismatch, and delivers a clean report -- no human touched a browser.

These are not demos. These are workflows that run today with Oloo Agent's building blocks. Chat is the interface. Skills are the workflows. Triggers are the scheduler. Hooks are the control plane. Scripts are the glue code. And 41 CDP Tools are the hands that do the work. Combine them, and your browser becomes an autonomous operator -- not a chatbot with a sidebar.

Infrastructure

41 CDP tools. Not a wrapper around a chat API.

Most browser AI tools stop at "summarize this page." Oloo Agent goes further. Its 41 tools use Chrome DevTools Protocol -- the same interface that powers Chrome's built-in developer tools -- to give any LLM direct, precise control over the browser. Click elements by CSS selector. Fill form fields with real keyboard events. Capture network traffic. Read the accessibility tree. Execute JavaScript in any frame. Take full-page screenshots. Navigate, scroll, wait, and observe. These are the building blocks that turn a language model into an actual browser agent.

One extension. Eight providers. Your API key.

Oloo Agent connects directly to 8 LLM providers: OpenAI (GPT-4o, o1), Anthropic (Claude 3.5/4), Google (Gemini), DeepSeek, GLM (Zhipu), Kimi (Moonshot), Qwen (Alibaba), and Doubao (ByteDance). Enter your API key in settings and start chatting. No Oloo account. No API proxy. No per-message fees from us. Your prompts go straight to the provider, and their responses stream directly to you. Switch models between messages or mid-task -- each conversation remembers which model sent which response.

Bring your own API key. No middleman. Your prompts go directly to the provider.

Privacy is not a feature. It is the architecture.

All data stays local.

API keys, chat history, skills, and settings are stored in Chrome's local storage on your machine. Oloo Agent has no servers, no databases, no user accounts. There is nothing between you and your data.

No telemetry. No analytics. No tracking.

Oloo Agent does not phone home. It does not count your messages, log your browsing, or fingerprint your usage. Install it, disconnect from the internet (except for LLM API calls), and it works exactly the same.

Optional sync is opt-in and encrypted.

If you want cross-device access, you can connect your own Supabase instance. The sync is end-to-end encrypted and entirely under your control. We do not run the sync server -- you do.

Your browser, your rules, your agent.

Open source. MIT licensed. Read every line.

MIT licensed. Community-driven. Contributions welcome.

Oloo-AI / Oloo-Agent

Oloo Agent is fully open source under the MIT license. The entire codebase -- every tool, every provider adapter, every UI component -- is available on GitHub. Audit the permissions. Read the code that handles your API keys. Verify that nothing leaves your machine. Fork it and build something we never imagined.

TypeScript MIT License

View on GitHub

+ contributors

We chose MIT because we believe developer tools should be owned by the people who use them. No CLA. No "open core" bait-and-switch. The extension you install is the same code that is on GitHub.

Start observing. Keep outgrowing.

The OLOO cycle works: observe pages, learn their content, organize your knowledge, and outgrow manual tasks with 41 automation tools. Install Oloo Agent, try the tools, break something, file an issue, submit a PR. Every cycle makes it stronger.

Get Oloo Agent ☆ Star on GitHub

Install in 2 minutes ▼

Download the latest release from GitHub (.zip file)
Open chrome://extensions in Chrome
Enable "Developer mode" (top right toggle)
Click "Load unpacked" and select the extracted folder
Pin Oloo Agent to your toolbar and press Alt+K to open the side panel

Chrome Web Store listing is coming soon. For now, manual install via GitHub is the only method.

Observe. Learn. Organize. Outgrow.