You are looking at a macOS desktop, with four windows running:

1. Google Chrome, running SLICC as a web application. It shows a Welcome page, a hidden tab with meeting preparation notes that were created by the agent, and a terminal, showing that the operating system is of the unlikely Mozilla/5.0 kind. What?
2. Slack, the desktop app. Err. Slack the Electron app. It has an overlay injected, showing the ice cream logo asking to join a tray. If you do this, Slack can be remote-controlled by your agent. What the?
3. Sliccstart, the desktop app. It's an actual macOS app, but one that controls browsers, and browsers that pretend to be native apps alike. What the ice cream?
4. An image of an anthropomorphized ice cream cone made out of felt and googly eyes. It's sticking out its tongue, half in astonishment, half in anticipation. What the ice cream truck?

If this scares, confuses, or excites you, keep reading.

slicc — Self-Licking Ice Cream Cone

A browser-native AI agent for getting practical work done in and through the browser.

🍦 Home page & hosted app: www.sliccy.com

SLICC runs in a browser and controls the browser it runs in. It combines a shell, files, browser automation, and multi-agent delegation so you can do real work from one workspace — coding, web automation, authenticated app tasks, and the weird in-between jobs that do not fit neatly inside a chat panel. SLICC can orchestrate multiple browsers, and even some apps through telepathy, making it a powerful hub for your digital work.

The fastest ways to try it:

• Open www.sliccy.com in Chrome — the hosted webapp boots SLICC straight in your browser tab.
• Install the macOS app — grab the latest .dmg from releases. No Windows or Linux UI yet.
• Run the CLI — npx sliccy launches Chrome with the local workspace attached. Node 22+ required.
• Load the Chrome extension — a thin per-page launcher that drops SLICC into any tab.

Once you're in, you can:

• Connect other browser windows or Electron apps into one shared session
• Install skills that teach the agent how to perform challenging tasks
• Give it practical tools models already know how to use (bash, git, node, python, playwright)
• Delegate parallel work to sub-agents so tasks get done faster

Status: active working prototype. The macOS app is the easiest way in today; the extension has been submitted to the Chrome Web Store.

Why SLICC is different

• Browser-native, not browser-adjacent. The agent runtime lives in the browser, and the agent can act on the same browser it lives in. A great mix of power and containment. If you don't like what the AI does, close the browser tab and it's over.
• A real shell environment. Many browser agents are constrained by the tools provided to them. SLICC has an almost-too-real shell with commands like git, "node", python, playwright, built-in.
• UI on the fly. SLICC can generate rich user interfaces on the fly. These can be small visualizations in a chat response, or full-blown web applications that run in a sidebar, or even a separate tab.
• Built around Skills. Agents don't suffer from missing capabilities, they suffer from skill issues. SLICC can install native skills into /workspace/skills, and it also discovers compatible .agents / .claude skills read-only across the reachable VFS.
• More than a coding panel. Coding is one strong use case, but SLICC is built for practical browser work too: authenticated web apps, repetitive tab work, content operations, debugging, research, and automation.
• Works across runtimes. Start in the CLI, run the thin Chrome extension that loads SLICC from sliccy.ai, connect multiple tray sessions, attach to Electron apps, embed SLICC into any third-party page via the @ai-ecoverse/cherry host SDK, or join from an iOS follower (SliccFollower) — all on the same core.
• Delegates in parallel. The main agent can spin up isolated sub-agents for task-specific work instead of stuffing everything into one conversation.

Who it is for

SLICC is for you if:

• you spend a lot of your day in browsers, terminals, and web apps
• you want an agent that can act, not just answer
• you are curious about automation, shell tools, and technical workflows
• you want one system that can span local dev work, browser tasks, and Electron surfaces
• you are an AI/web-dev-adjacent builder, power user, who's comfortable with things being broken from time to time (we are working hard to make this smoother)

What you can do with it

• Launch an agent from the CLI and let it work in the browser it controls. Start one command, open the workspace, and give the agent shell tools, files, and live browser access in one place.
• Automate repetitive workflows in authenticated web apps. Use browser automation, page inspection, screenshots, storage access, and scripted tab control where your logged-in browser session already has the context.
• Hand work off from another coding agent into your live browser session. Open any URL whose response carries an RFC 8288 Link header with a SLICC handoff or upskill rel (the tray-hub /handoff?handoff=... / ?upskill=... endpoint is a convenience) and SLICC prompts you to approve the action inside the Chat tab.
• Solve technical tasks with practical tools. Reach for bash, git, grep, node, python, previews, and browser automation when the job is bigger than text generation.
• Add visual and file context directly in chat. Drop images or files onto the workspace, or use the paperclip button. Dropped .skill archives still install into /workspace/skills.
• Delegate parallel work to scoops. Split tasks into isolated sub-agents with their own sandboxes and context, then let the main agent coordinate the results.
• Turn one-off wins into reusable workflows. Package behavior as skills, build interactive sprinkles, and react to external events with webhooks and cron-driven licks.
• Mount your local file system. By default, SLICC is confined to your browser. But you can ask it to mount folders from your local file system, so it can read and write from there. Mount into an empty path such as /mnt/myproject so you do not hide existing skills or scripts.
• Mount remote storage as if it were local. Beyond local folders, mount --source bridges S3 buckets, S3-compatible services like Cloudflare R2 and MinIO, and Adobe da.live repositories into the same VFS surface. Reads use TTL+ETag caching with conditional revalidation; writes use ETag-conditional PUTs that surface concurrent-edit conflicts as EBUSY. Credentials live server-side (~/.slicc/secrets.env in CLI, chrome.storage.local in the extension via the Extension options page) and never reach the agent. After setup: mount --source s3://my-bucket --profile r2 /mnt/r2 or mount --source da://my-org/my-repo /mnt/da. See docs/mounts.md for the full guide.

Getting started

1. Quick start with npx

The fastest way to try SLICC — no clone, no install:

npx sliccy

This downloads the latest release, launches Chrome, and opens the workspace. Configure your LLM provider in the first-run settings dialog. Requires Node >= 22.

2. Install globally

If you plan to use SLICC regularly:

npm install -g sliccy
slicc

3. Run from source (contributors)

git clone https://github.com/ai-ecoverse/slicc.git
cd slicc
npm install
npm run dev

npm run dev runs the node-server with Vite HMR, launches Chrome, and opens the workspace on http://localhost:5710. npm start runs the pre-built bundle from dist/, so use it only after npm run build.

• Optionally pre-configure providers: cp packages/dev-tools/providers.example.json packages/webapp/providers.json
• See packages/dev-tools/providers.example.json for the available provider fields.
• For contributor-focused setup details, see docs/development.md.

4. Chrome extension

The extension is a thin CDP bridge + per-page launcher — no bundled UI, no offscreen agent engine. The full SLICC webapp loads from the hosted leader tab (https://www.sliccy.ai/?slicc=leader); the extension just pins that tab, proxies chrome.debugger to it, and injects a small <slicc-launcher> overlay into every page.

npm install
npm run build -w @slicc/chrome-extension

Load dist/extension/ as an unpacked extension in chrome://extensions. The service worker pins the hosted leader tab on install; clicking the toolbar icon focuses it (or recreates it if the user closed it). Each page you visit gets the launcher overlay, which iframes the same hosted webapp as an auto-follow follower.

5. Run a second browser

SLICC can mirror itself across multiple browsers, even on other machines:

1. First browser: click your avatar in the top-right header and choose Enable multi-browser sync. A dialog opens with the sync URL (already copied to your clipboard) and step-by-step instructions. The same dialog has a Reset URL button if you want to invalidate the link and disconnect connected browsers. (You can also type host in the built-in terminal to print the URL.)
2. Second browser: open the account dialog, click Connect to another browser, and paste the URL. The "How do I get the sync URL?" hint inside the dialog walks through the same steps.
3. Leaving the tray: click the avatar on either browser to open the popover — the tray section now has a Stop multi-browser sync (leader) or Disconnect from leader (follower) action. From the terminal, host leave does the same thing; host leave --leader <worker-url> leaves the current role and becomes a leader on that worker.

Both browsers must run the same SLICC version. Once connected, the sessions stay in sync in real time.

6. Electron

SLICC can also attach to Electron apps and inject the same shared overlay into their pages. The best way to use it with Electron apps is to use the Join Tray feature, so that the Electron app becomes a remote-controllable target.

npm run dev:electron -- /Applications/Slack.app

For the full Electron workflow, see docs/electron.md.

How it works

SLICC shares one core across every runtime ("float"). The browser is not just where you view the product — it is where the agent runtime lives.

• Browser-first runtime: the agent loop, virtual filesystem, shell, UI, and tools run client-side.
• Thin server where needed: the CLI path mainly exists to launch Chrome, proxy CDP, and bridge the few things browsers cannot do alone. The Chrome extension is even thinner — UI and agent engine load from the hosted leader tab.
• One model across floats: CLI / standalone, thin Chrome extension, Electron, Cherry (embedded follower in third-party pages), hosted-leader / cloud (@slicc/cloud-core over an e2b sandbox), and the native macOS / iOS surfaces (Sliccstart, slicc-server, SliccFollower) all reuse the same underlying system.
• Cone + scoops delegation: the main agent orchestrates; sub-agents execute in isolated sandboxes and report back.
• Skills explain the world to the agent: don't expect the agent to know everything, ask it to search and install skills that are relevant to the task.

The SLICC vocabulary and lore

Once the product makes sense, the ice-cream language is easier to enjoy: it maps to real architecture, not just mascot energy.

• Cone — the main agent you interact with. It holds the broad context, owns the overall workflow, and delegates work.
• Scoops — isolated sub-agents with their own filesystem sandbox, shell, and conversation history.
• Licks — external events that wake an agent up: webhooks, cron jobs, and other signals from the outside world.
• Floats — normal engineers would call it runtimes, but would normal engineers have come up with this?
• Tray — multiple floats can form a tray, a joint session with remote control.
• Sprinkles — everything is better with sprinkles: small, optional enhancements you can add on top of the core system.

Why the name? SLICC stands for Self-Licking Ice Cream Cone: a recursive system that can help build, extend, and operate itself. A browser agent running inside the browser: that's as self-recursive as tongue-out gelato.

API Keys and Providers

To use SLICC, you need an LLM provider. SLICC is very much a BYOT (bring your own tokens) affair. We have built-in support for many providers, and these have actually been tested.

• Adobe (for AEM customers. Talk to the team to get enabled)
• AWS Bedrock (because enterprise)
• AWS Bedrock CAMP (this is Adobe-internal. Did I say "because enterprise" already?)
• Anthropic

The other providers are in YMMV territory. Please file an issue if you find them working or broken.

Secrets

SLICC can safely manage API keys, tokens, and credentials with domain-scoped injection. The agent never sees real secret values — only masked placeholders — and secrets are only injected into requests destined for authorized domains. This protects against prompt-injection attacks that try to exfiltrate credentials.

See docs/secrets.md for setup instructions.

Related projects and lineage

SLICC is part of the AI Ecoverse, a growing set of AI-native tools and workflows. Its distinctive angle is simple: browser-native, practical, and job-oriented.

• yolo — worktree-friendly CLI launcher for AI agent workflows
• upskill — installs reusable agent skills from other repositories (and built-in in SLICC)
• ai-aligned-git and ai-aligned-gh — guardrails and attribution helpers for AI-assisted Git/GitHub work

SLICC would not have been possible without the pioneering inspiration of OpenClaw, NanoClaw, and Pi. Pi is actually the frozen heart of every SLICC instance.

Development and deeper docs

If you want to go deeper, the detailed docs live here:

• Development guide
• Architecture
• Testing
• Shell reference
• Secrets
• Mounts (local + S3 / R2 / DA)
• Adding features
• Electron notes