HANDS-ON WORKSHOP实战工作坊 SYDNEY悉尼

Let AI Run
Your
LinkedIn

让 AI 接管
你的 LinkedIn

Watch it work once. Then make it yours. 先看它跑一次，再把它变成你自己的。

01 · ROOM CHECK01 · 现场调查 LISTEN FIRST先听大家

Know the Room First

先认识一下彼此

01What do you do?你目前从事什么工作？

02How long have you used Codex?你使用 Codex 多久了？

03What do you want to learn today?今天最希望学会什么？

02 · LIVE DEMO02 · 现场演示 REAL ACCOUNT · COMPLETE FLOW真实账号 · 完整流程

Complete a LinkedIn Engage

完成一次完整的 LinkedIn Engage

STEP 01Browse the feed浏览动态

STEP 02Choose a post选择帖子

STEP 03Pick a reaction选择 Reaction

STEP 04Write & publish生成并发布评论

This is live: the AI reads first, then decides how to engage.不是预录：让大家看到 AI 先读内容，再决定如何互动。

03 · THE MODEL03 · 背后的结构 THREE WORDS三个关键词

Agent, Skill, and Tool

Agent、Skill 和 Tool 到底是什么？

AI＋ Instructions＋ Tools＝ Agent

AI ＋指令＋工具＝ Agent

Skill＝ a repeatable workflow

Skill ＝可重复调用的工作流程

A browser is one tool an Agent can use.浏览器，就是 Agent 可以调用的一种工具。

04 · BUILT-IN TOOL04 · 内置工具 COPY, PASTE, RUN复制、粘贴、运行

Try the Built-in Browser

先体验 Codex 自带的浏览器

Your first hands-on task. Nothing to install.第一次动手，什么都不用装。

01Copy, paste into Codex, run复制，粘贴进 Codex，运行

02Watch it browse and answer看它自己上网、给出答案

05 · WHY CONNECT05 · 为什么用 CONNECT LINKEDIN

LinkedIn Detects the Browser

LinkedIn 会检测浏览器

Codex BrowserCodex 浏览器

Detected被检测

Connect BrowserConnect 浏览器

Undetected检测不到

06 · INSTALL YOUR AGENT06 · 装好你的 Agent COPY → PASTE → DONE复制 → 粘贴 → 完成

Install Your Agent

一键装好你的 Agent

---
name: install-connectonion
description: Install ConnectOnion and configure everything on Windows, macOS, or Linux — find Python, install the package, scaffold a project, set up API keys (managed or own), install a browser if needed — then verify with a real run and hand the user a plain-language account summary. Use when the user says "install connectonion", "set up connectonion", "get me started with co", or a co command fails because nothing is configured yet.
tools:
  - Bash(python *)
  - Bash(python3 *)
  - Bash(py *)
  - Bash(pip *)
  - Bash(pip3 *)
  - Bash(co *)
  - Bash(patchright *)
  - shell
  - read_file
  - write
  - edit
---

# Install ConnectOnion Skill

Take a machine from nothing to a working, configured agent — on **whatever operating
system the person is using** — then tell them, in plain words, exactly what they have.

**Assume the person running this may not be technical.** They may not know what a
"virtual environment", a "PATH", or an "API key" is, and that's fine — your job is to do
the technical work *for* them and keep them informed in friendly, jargon-free language.
Never dump a raw stack trace at them; translate every problem into "here's what happened
and here's what I'm doing about it."

## How to run this skill

1. **Work on the user's real OS.** Windows, macOS, and Linux differ in command names and
   shells. Do Step 0 first and use the right commands for that platform — don't assume
   `python3`, `grep`, or `bash` exist everywhere.
2. **Verify every step before moving on.** Never assume a command worked — check its
   output. Each step has a check; run it.
3. **Auto-correct instead of giving up.** When a step fails, do NOT stop and paste the
   error. Diagnose the cause, apply the known fix (the *Recovery* box under each step),
   and retry. Give each fix **up to 2 attempts** before escalating.
4. **Only ask the human for things only a human can do** — logging in through a browser,
   adding money, choosing a project name. Ask in one plain sentence.
5. **Keep them in the loop.** A short friendly line before each phase ("Installing now —
   about 30 seconds…") beats silence.
6. **Never print or store secrets.** Confirm a key is *present*, never show its value.

## Step 0: Know the machine

Figure out the platform and which commands to use. **Everything below writes `PY` for
"the Python command that works on this machine"** — resolve it once here, then reuse it.

- **Detect the OS.** If you have a shell, `uname` (prints `Darwin`/`Linux`) vs. failing =
  Windows is a quick tell; otherwise use whatever platform signal you have.
- **Find Python (needs 3.10+).** Try these in order and keep the first that prints 3.10 or
  newer — that is `PY`:

  ```bash
  python3 --version      # macOS / Linux usually
  python --version       # Windows usually, sometimes macOS/Linux
  py -3 --version        # Windows Python launcher
  ```

- **Pick the right shell.** On macOS/Linux the `bash` tool is fine. **On Windows the
  `bash` tool does not work** (it's Unix-only and returns an error) — use the
  cross-platform `shell` tool instead, and don't rely on `grep`/`cat`/`ls`. Prefer
  `co …` commands and `PY -c "…"` snippets, which behave the same everywhere.

> **Recovery**
> - None of `python3` / `python` / `py -3` is found, or all are < 3.10 → Python isn't
>   installed (or is too old). Tell the person plainly and give the path for *their* OS:
>   - **Windows:** install from python.org (tick "Add python.exe to PATH"), or
>     `winget install Python.Python.3.12`. Afterward `py -3` works.
>   - **macOS:** install from python.org, or `brew install python@3.12`.
>   - **Linux:** use the distro package manager (e.g. `sudo apt install python3 python3-venv python3-pip`).
>   Don't install system Python yourself unless they ask.

## Step 1: Isolate with a virtual environment (recommended)

Keeps this install tidy and avoids "externally-managed-environment" errors:

```bash
# macOS / Linux
PY -m venv .venv && source .venv/bin/activate

# Windows (PowerShell)
py -3 -m venv .venv ; .venv\Scripts\Activate.ps1
# Windows (cmd)
py -3 -m venv .venv & .venv\Scripts\activate.bat
```

After activating, `python`/`pip` point inside `.venv` — from here `PY` can just be
`python`. If venv creation fails, it's optional: skip it, continue globally, and note
that to the user.

## Step 2: Install the package

Use `PY -m pip` (works even when a bare `pip` isn't on PATH):

```bash
PY -m pip install connectonion       # add -U to upgrade an existing install
```

Verify before continuing:

```bash
co --version    # prints the installed version
co doctor       # cross-platform health check: Python, config, keys, browser
```

> **Recovery**
> - `co: command not found` after a successful install → the scripts folder isn't on
>   PATH. Confirm the package works with `PY -m connectonion.cli.main --version`; if that
>   prints a version, either use `PY -m connectonion.cli.main …` for the rest, or reinstall
>   with `pipx install connectonion` (which puts `co` on PATH).
> - "externally-managed-environment" / permission error → go back to Step 1 and use the
>   venv (exactly what it prevents), then retry.

## Step 3: Create or initialize a project

A project is just a folder with a `.env` (its keys) and a `.co/` folder (its config +
identity). The CLI is cross-platform here — the same commands work on every OS.

**New project** — **always pass `--yes`** so it doesn't stop to ask questions:

```bash
co create my-agent --yes                            # minimal (default)
co create my-coder --template coder --yes           # bash + file editing
co create my-bot --template browser --yes           # browser automation (see Step 6)
co create my-researcher --template web-research --yes
```

Other templates: `hosted-browser`, `co-ai`, `custom` (with `--description "..."`).

**Existing directory** — add config in place: `co init --yes` (config only) or
`co init --template minimal --yes` (full starter). The first run on a machine also
creates the global `~/.co/` config (keypair, agent address, agent email) automatically.

Confirm it worked with a cross-platform check (don't use `ls` — it's not on Windows):

```bash
co doctor       # its Config/Keys lines show ✓ when .co/ and keys exist
# or, portably:
PY -c "import os; print('OK' if os.path.exists('.env') and os.path.isdir('.co') else 'MISSING')"
```

> **Recovery**
> - "Directory not empty" warning → the folder already has files. Add `--force` only after
>   the person confirms it's safe to write here.
> - The command hangs → it's waiting on an interactive prompt; you forgot `--yes`. Re-run
>   with `--yes`.
> - `.env` / `.co/` missing afterward → re-run and read the output before continuing.

## Step 4: Configure model access (pick ONE path)

An agent can't think without a model. Two paths — pick by what the person has.

**Path A — managed keys (recommended; no provider account, comes with free credit):**

```bash
co auth
```

Logs them in and saves `OPENONION_API_KEY` to `~/.co/keys.env` (and the project `.env`).
Agents then use `co/*` models — `co/o4-mini`, `co/gpt-4o`, `co/claude-sonnet-4-5`,
`co/gemini-2.5-pro` — with nothing else to configure. `co auth` opens a browser login, so
hand off: *"Please finish the login in the browser window that opened — I'll continue
once you're back."*

**Path B — their own provider key:** add it to the project `.env` with the `write`/`edit`
tool (never echo the value back afterward):

```
OPENAI_API_KEY=sk-...        # for gpt-* models
ANTHROPIC_API_KEY=sk-ant-... # for claude-* models
GEMINI_API_KEY=...           # for gemini-* models
```

Model name picks the provider: `gpt-*` → OpenAI, `claude-*` → Anthropic, `gemini-*` →
Google, `co/*` → managed keys.

Verify (cross-platform — `co doctor` reports where it found the key, no `grep` needed):

```bash
co status       # Path A: shows account, balance, and free credit
co doctor       # either path: the "API Key" line shows ✓ Found in .env / keys.env
```

> **Recovery**
> - `co auth` login didn't complete → safe to re-run; it refreshes the token in place.
> - "No API key found" → the key didn't land. Re-run `co auth` (Path A) or re-check the
>   variable name spelling in `.env` (Path B).

## Step 5: Verify with a real run

Prove the whole chain works with a tiny 2-line agent. **Match the model to the path from
Step 4** — the default model is a managed `co/*` one, so a Path-B setup must name its own
provider's model:

```bash
# Path A (managed keys — default model):
PY -c "from connectonion import Agent; print(Agent('smoke-test', max_iterations=2).input('Reply with exactly: OK'))"

# Path B (own key — name a model your key serves, e.g. OpenAI):
PY -c "from connectonion import Agent; print(Agent('smoke-test', model='gpt-4o-mini', max_iterations=2).input('Reply with exactly: OK'))"
```

Expected: a reply containing `OK`.

> **Recovery — read the error and act, don't just report it**
> - `InsufficientCreditsError` → the managed account is out of credit. A *money* thing only
>   the person can fix: show the address and balance from `co status`, point them to top up
>   (https://o.openonion.ai/purchase) or Discord (https://discord.gg/4xfD9k8AUF). Not an
>   install failure.
> - Auth / `401` → the key from Step 4 didn't land. Re-run `co auth` (A) or fix `.env` (B),
>   then retry once.
> - `ModuleNotFoundError: connectonion` → wrong Python/venv is active. Re-activate the venv
>   from Step 1 and retry.

## Step 6: Browser setup — ONLY if they need web automation

Skip this entirely unless the person chose the `browser` / `hosted-browser` template or
wants the agent to drive a web browser. **This is a real gotcha:** `pip install
connectonion` installs the browser *library* (`patchright`) but **NOT a browser to
drive**. Without one, browser commands fail.

The agent looks for a **real Google Chrome** first (auto-detected on Windows, macOS, and
Linux). If Chrome isn't installed, install Patchright's own browser:

```bash
PY -m patchright install chrome    # downloads a Chromium the agent can drive
```

Verify:

```bash
co doctor       # the Browser line reports ok / broken / missing
```

> **Recovery**
> - `co doctor` browser line says **missing** → run `PY -m patchright install chrome`.
> - Says **broken** (stealth driver) → `PY -m pip install --force-reinstall --no-cache-dir patchright`, then re-run `patchright install chrome`.
> - Still failing → check `~/.co/browser.log`; the person may simply install desktop Google
>   Chrome, which the agent will pick up automatically.

## Step 7: Hand the user a plain-language summary

The payoff. Run `co status` and turn it into a short, friendly summary — **don't paste the
raw panel**, translate it.

```bash
co status
```

Map the `co status` fields to plain language:

| `co status` field | Say it like this |
|--------------------|------------------|
| Credits            | 🎁 **Free credit from ConnectOnion** — money they gave you to start |
| Balance            | 💰 **Money available right now** to run your agent |
| Total Spent        | what's been used so far |
| Email              | 📧 **Your agent's own email address** (it can send/receive mail) |
| Agent ID / Address | your agent's unique ID |

Then present something like this (fill in the real values):

```
✅ You're all set up! Here's your ConnectOnion account:

  🎁  Free credit ConnectOnion gave you:  $X.XX
  💰  Money available to use now:          $X.XX
  📧  Your agent's email address:          you@mail.openonion.ai
  🤖  Model access:                        managed (co/* models) — nothing else needed
  📦  Installed:                           connectonion vX.Y.Z  (Python 3.12 on Windows)
  📁  Your project:                        ./my-agent  (minimal template)

  You can start using your agent now. If the balance ever runs low, you can add
  more at https://o.openonion.ai/purchase — the free credit is enough to get going.
```

Adjust for the situation:
- **Balance $0 / low** → say it gently: "Your free credit is used up, so you'll need to add
  a little to keep running the agent — here's where: …". No alarm, no jargon.
- **Path B (own keys)** → replace the money lines with "Model access: your own <provider>
  key"; skip balance (their provider bills them directly).
- **Browser installed** → add "🌐 Browser: ready".
- **Integrations connected** → add "📬 Connected: Gmail" etc.

Keep it to the handful of lines that matter to *this* person. Warmth over completeness.

## Notes

- **Cross-platform:** the `co` CLI runs on Windows, macOS, and Linux. The gotchas are (1)
  the `bash` *tool* is Unix-only — use `shell` on Windows; (2) `python3` may be `python`
  or `py -3` on Windows (that's why Step 0 resolves `PY`); (3) the browser binary is never
  auto-installed (Step 6).
- `--yes` on `co create` / `co init` is mandatory for unattended runs, or the command
  blocks on prompts.
- Never print, log, or commit API keys. Templates gitignore `.env` — keep it that way.
- `co auth` is safe to re-run; it refreshes the token in place.
- A failing smoke test with a green `co doctor` / `co status` is a model-or-credit issue,
  not an install issue — say so plainly.
- All state lives in `~/.co/` (global identity + keys) and the project's `.co/` + `.env`.
  Deleting one project never breaks another.

One copy. One paste.复制一次，粘贴一次。

Codex installs everything — then your Agent sends its first email.Codex 自己完成安装——然后你的 Agent 会发出它的第一封邮件。

When Codex asks to run a command, click Approve. A computer-password request just means Python is installing.Codex 请求运行命令时点 Approve 即可；要求输入电脑密码是在安装 Python，属正常。

07 · THE MAGIC MOMENT07 · 魔法时刻 LIVE INBOX收件箱直播

Your Agent’s First Email

你的 Agent 的第一封邮件

STEP 01It lands in Aaron’s inbox邮件到达 Aaron 的收件箱

STEP 02Your Agent gets $99你的 Agent 获得 $99 credit

STEP 03A reply confirms it回信确认，Agent 正式上岗

Your Agent just sent its first email — and earned its first money.你的 Agent 刚发出它人生第一封邮件——而且已经赚到第一笔钱。

08 · INSTALL A SKILL08 · 安装 Skill COPY → PASTE INTO CODEX → RUN复制 → 粘贴到 Codex → 执行

Two Skills: Browser + Email

装上双手：浏览器和邮箱

---
name: co-browser
description: Drive one persistent, logged-in browser from the shell with the `co browser` CLI — navigate, click, type, screenshot, extract data, or hand a natural-language task to the AI agent via `do`. Handles site signup/registration autonomously using the agent's own email (`co status` for the address, `co email inbox`/`read` for verification codes). Use when the user wants browser automation, web scraping, logged-in site workflows, account signup/registration, or says "co browser", "open the browser", "check that page", "click/type on a website", "sign up for".
---

# co browser

Drive **one persistent browser** from the shell. The browser stays open between commands — cookies and logins persist until `co browser close`. Every terminal on the machine talks to the same daemon, so there is one browser and one tab board no matter where you type.

Output contract: **stdout = data, stderr = errors.** Exit codes: `0` ok · `1` action failed · `2` usage error · `3` unknown tab · `4` tab busy.

## Hard gate — required before every `do` job

`do` is not the default browser interface. Use it only for one bounded judgment step inside an otherwise stable, tested direct-function workflow. **All of these must be true before dispatch:**

1. The user explicitly approved using `co browser do` and accepts that it globally blocks the browser and has no reliable soft-cancel once the daemon loop starts.
2. The site workflow has already been inspected with `save_page_context`; login, intended end state, and recovery path are known.
3. No other agent, scheduler, terminal, or browser task is active. The daemon must be exclusive for the entire job.

Run both commands and read their output:

```bash
co browser status
co browser tab ls --json
```

- Preserve the browser mode reported by `status`; do not call `open_browser`, `close`, or change headless mode when a shared browser is already running.
- If another agent owns `main` or has active browser work, **do not run `do` at all**. Use direct functions in a dedicated named tab or wait until the daemon is exclusive.
- Check OS processes as well as the tab board: `ps -axo pid,ppid,stat,etime,command`. A parent scheduler or terminal can keep spawning new `co browser` clients even when the current child exits.
- **禁止：在工作流尚未稳定、用户未明确批准、或任何其他浏览器任务仍活跃时运行 `co browser do`，无论是否使用命名标签。**
- A named tab prevents page collisions; it does **not** provide command concurrency. The daemon executes one command globally at a time.
- When finished in a shared browser, close only the tab you opened. Do not stop the shared daemon.

## Two ways to drive it

1. **Direct functions** (deterministic, fast, free) — prefer these for anything scriptable:

```bash
co browser go_to https://example.com/login       # navigate (https:// assumed if omitted)
co browser get_text                              # page's visible text
co browser get_links_from_page                   # every link, one per line
co browser take_screenshot                       # saves a PNG, prints its path
co browser click_element_by_selector "#submit"   # deterministic click by CSS selector
co browser type_text_by_selector "#email" "user@example.com"
co browser save_state auth.json                  # export cookies/localStorage (keep secret!)
```

### Inspect → analyze → script on unfamiliar pages

Before writing JavaScript to extract data or perform page actions, capture the rendered page:

```bash
co browser -t "$TAB" save_page_context descriptive-name
# Read the printed page.html, elements.json, and relevant styles.css sections.
# Then write a page-specific script from the observed DOM/data structure.
co browser -t "$TAB" run_page_script /absolute/path/to/script.js '{"arg":"value"}'
```

- **Never write a page script from guessed selectors or an assumed DOM. Save and inspect page context first.**
- Prefer structured data found in the captured page (for example JSON-LD or `__NEXT_DATA__`) over pairing unrelated text and links heuristically.
- Re-save context after navigation, opening a modal, changing filters, or any other state change that makes the previous capture stale.
- Keep extraction scripts read-only. For action scripts, verify the intended target from context and take a screenshot after the state change.

Run `co browser help` for the full live list (~40 functions: scroll, hover, keyboard_press, wait_for_text, upload_file_by_selector, run_page_script, save_page_context, extract_items_by_selector, …). Positional args in order, options as `--flag=value`. Wrong arguments return the function's usage line so you can self-correct.

2. **`do "<instruction>"`** (exceptional, explicit opt-in) — an AI agent sees the live page and works out one bounded judgment step. Describe the **end state** ("download the June invoice PDF"), not the steps. Use it only after the hard gate above passes:

```bash
co browser do "log into github with saved credentials and open my notifications"
```

`do` is synchronous, may run for up to 200 agent iterations, and blocks the single-threaded daemon across **all** tabs until it returns. **Do not use `do` for multi-page collection, repeated extraction, status checks, login/verification recovery, or any workflow that direct functions plus a saved-context page script can perform.**

Bad: another task is active → open a named tab → run `do`. The named tab isolates page state but the `do` loop still blocks every agent globally.

Good: inspect the page → implement and verify direct selectors/page scripts → use `do` only for a remaining bounded judgment step, with an exclusive daemon and explicit user approval.

**禁止：用关闭 Chrome 标签、`tab close`、或杀掉等待中的 CLI client 来“取消”一个已经开始执行的 `do`。** Once the daemon has entered the agent loop, those actions do not cancel it; the background loop can keep navigating or opening pages while every new command reports `daemon is busy`. Let the originating job finish, or stop it at its owning task before dispatch. Restart the daemon only with explicit user authorization and only after confirming no other browser task needs it.

## One task = one tab

Solo use needs no ceremony — bare commands run on the shared **`main`** tab. Running a second concurrent task or agent? Give direct-function work its own tab and add `-t <name>` to **every** command:

```bash
NAME=$(co browser tab open --who claude --for "scrape pricing")   # prints only the tab name
co browser -t "$NAME" go_to https://example.com/pricing
co browser -t "$NAME" save_page_context pricing
# inspect the saved DOM, then use direct extraction or a verified page script
co browser tab close "$NAME"                                      # release when done
```

**Never use `do` as a concurrent second task.** A dedicated tab does not make it safe while another tab or agent is active.

See the board: `co browser tab ls` (add `--json` for scripting). Set `CO_WHO=<name>` in scripts so the board shows who you are (Claude Code sessions are identified automatically).

## Handling exit codes

- **exit 4 (tab busy)** — another agent is mid-task on that tab. Do NOT retry the same bare command; open your own tab (the error message shows the exact three commands). A crashed agent's claim expires in ~2 minutes.
- **exit 3 (unknown tab)** — `tab open` the name first; a tab must be registered before `-t` can drive it.
- **exit 1** — the action failed (e.g. selector not found); read stderr, adjust selector or use `save_page_context` / `take_screenshot` to inspect the page.

## Visible vs headless

Default is a **visible window** — right for logging in once or watching the agent work. Add `--headless` before the function to run windowless. The mode is fixed by whichever command starts the daemon (`co browser status` shows it); to switch, `co browser close` and rerun.

## Logins

First run opens a window you log into once; every later command is already authenticated (profile lives in `~/.co/browser_profile/`, surviving daemon restarts). For a login wall mid-flow, use `co browser wait_for_manual_login "site name"` to pause for the user.

## Signup / registration — use the agent's own email

If a site requires signup, don't stop to ask the user for an email. The agent has its own address:

```bash
co status                          # shows the agent's email (e.g. aaron@mail.openonion.ai)
```

Use that email in the registration form, then read the verification code or link from the agent's inbox:

```bash
co browser type_text_by_selector "#email" "<agent-email>"    # fill signup form
# ... submit the form, then poll the inbox:
co email inbox --unread            # list unread emails (or -n 5 for the last 5)
co email read <ID>                 # show one email's body — extract the code or link
```

Typical flow: fill the form with the agent's email → submit → `co email inbox --unread` (the verification mail may take ~10–30s; wait and retry a few times) → `co email read <ID>` → type the code with `type_text_by_selector`, or `go_to` the verification link in the same tab. The site login then persists in the browser profile like any other login.

Email verification also works for email-code sign-in (magic links, OTP login) — same inbox flow, no signup needed. `co email send` can send from the agent's address if a flow requires replying.

## Verify with screenshots

After any state-changing action (click, type, submit), verify before proceeding:

```bash
co browser take_screenshot        # prints the PNG path — Read it to confirm the page state
```

## Troubleshooting

- **"daemon is busy" after ~15s** — a long `do` holds the single-threaded daemon. Do not pile up `status`, new-tab, screenshot, or retry clients: they cannot bypass the global lock. Closing the visible tab will not cancel the loop. Read `~/.co/browser.log` to confirm progress, wait for the owning job to return, then run `co browser status` once.
- **Runaway `do` and the user explicitly authorizes a force-stop** — stop in this order:
  1. Use `ps -axo pid,ppid,stat,etime,command` to identify the originating parent scheduler/terminal, every `co browser` client, and `connectonion.cli.browser_agent.daemon`.
  2. Kill the originating parent first so it cannot respawn clients; then kill all browser clients; kill the daemon last. Saved logins remain in the browser profile.
  3. Verify shutdown with `ps`, not with any `co browser ...` command. `co browser status`, `get_current_url`, and similar probes can auto-start a new daemon.
  4. If a client or daemon reappears, find and stop its parent process before killing it again. Do not declare the loop stopped until `ps` shows zero browser clients and zero daemons.
- **Late navigation after apparent cancellation** — a queued command or still-running daemon loop executed after the CLI client/tab was closed. Treat this as proof that cancellation failed; use the force-stop sequence above when authorized.
- **"Chrome failed to start"** — usually ssh/cron without a desktop session (use `--headless`), or a leftover Chrome holds the profile. Launch log: `~/.co/browser.log`.
- **Daemon-only nuclear option** (explicit user authorization required; first stop parent schedulers and clients as above):

  ```bash
  pkill -f connectonion.cli.browser_agent.daemon
  ```

Full reference: https://docs.connectonion.com and `co browser help`.

Two copies. Two pastes.复制两次，粘贴两次。

Install both, then start a new conversation so they load.两个都装好，然后新建对话让它们加载。

09 · FIRST RUN09 · 第一次运行 SUCCESS FIRST先成功，再拆解

Run Your First External Skill

运行第一个外部浏览器 Skill

Use the co-browser skill: open LinkedIn and confirm I am logged in.

01Start a NEW conversation — skills load there先新建对话，Skill 才会被加载

02The Connect browser window opensConnect 浏览器窗口自动打开

03Log in once — the session is saved for every later run登录一次，之后每次运行都复用这个会话

04A screenshot confirms your feed is visible用截图确认已经进入信息流

One goal for the first task: everyone gets it running.第一次任务只追求一件事：每个人都成功运行。

10 · CREATE A SKILL10 · 创建 Skill ONE SKILL, ONE JOB一个 Skill，一个任务

Create Your First Skill

创建自己的第一个 Skill

01 · TASKWhat is the job?任务是什么？

02 · INPUTWhat goes in?需要什么输入？

03 · STEPSWhat are the steps?按什么步骤做？

04 · STOPWhen should it stop?什么时候停止？

Copy this prompt — Codex interviews you through the four boxes, then writes the Skill for you.复制这段提示词：Codex 按四个格子逐一问你，然后帮你把 Skill 写出来。

11 · AUTOMATION FLOW SKILL11 · 自动化流程 SKILL DISCOVER → VERIFY → REPEAT探索 → 验证 → 复用

Explore First, Then Lock the Flow

先探索真实页面，再把流程固定下来

Explore a New Flow探索新流程

Observe one safe run on the real page在真实页面安全观察一次
Save screenshots and page context保存截图和页面上下文
Find stable controls and stop conditions找到稳定控件和停止条件

Lock a Repeatable Flow固定可复用流程

Create extraction and verification scripts生成提取与验证脚本
Test again with different input换一份输入重新测试
Stop and leave evidence on mismatch不匹配就停止并留下证据

The full Skill is included here—open it to read, or copy it directly.完整 Skill 已经放在这里：可以展开阅读，也可以直接一键复制。

12 · EXTEND & SPEED UP12 · 扩展与提速 STABLE FIRST先稳定，再复杂

Add Capabilities After It Works

稳定以后，再增加能力

Media图片 / 视频Upload files and prepare a content draft上传媒体，完成内容草稿

People search人物搜索Find people and organise public information找到目标人物，整理公开信息

Message draft消息草稿Generate copy; a human confirms the send生成内容，最终发送由人确认

Faster runs执行提速Reuse sessions and scripts; analyse less复用会话与脚本，减少重复分析

13 · AUTOMATION13 · 自动运行 AI PREPARES · PEOPLE DECIDEAI 准备，人决定

Automate Only After It Is Stable

稳定以后，再让它自动运行

Prepare Overnight夜间准备

Generate content, organise assets, and build tomorrow’s task queue.定时生成内容、整理素材、建立第二天的待办队列。

Review in Daylight白天确认

Review outputs and errors; people confirm publishing and sending.查看结果和错误记录；发布、发送等动作由人确认。

Production service covers monitoring, upgrades, permissions, maintenance, and custom workflows.生产服务负责监控、升级、权限、维护和复杂定制。

14 · SET UP REMOTE14 · 设置 REMOTE DESKTOP → QR → PHONE电脑 → 二维码 → 手机

Pair Your Phone in One Minute

一分钟，把手机和电脑配对

STEP 01Open Set up Remote电脑端点 Set up Remote

STEP 02Scan the QR code用手机扫描二维码

STEP 03Confirm your account确认同一账号与工作区

STEP 04Open Remote on mobile手机打开 Remote

Before the demo: update both apps; keep the host awake, online, and signed in.演示前先更新两端 App，并让电脑保持唤醒、联网、已登录。

15 · THE ONE LIMIT15 · 关键边界 REMOTE IS NOT THE HOSTREMOTE 不是运行主机

The Computer Still Does the Work

手机负责指挥，真正干活的仍是电脑

Phone sends手机发送

Prompts, approvals, follow-ups, and decisions.指令、批准、补充信息和你的判断。

Computer provides电脑提供

Files, credentials, plugins, browser sessions, and local tools.文件、账号、插件、浏览器会话和本地工具。

If the host sleeps, goes offline, or closes the app, Remote pauses. A Mac mini is optional—use one only when you truly need always-on access.电脑休眠、断网或关闭 App，Remote 就会暂停。Mac mini 只是常在线方案，不是入门门槛。

16 · BONUS16 · 加餐 DO IT AT HOME回家完成

Connect Your Own Email

连上你自己的邮箱

co outlook

01A Microsoft login window opens弹出微软登录窗口

02Sign in once登录一次

03Your inbox now works from Codex你的收件箱从此可以被 Codex 使用

Homework — one login, no rush. Today your Agent’s own email is enough.回家作业：只需登录一次，不着急。今天用 Agent 自己的邮箱就够了。

17 · WRAP UP17 · 收尾 RECAP · COMMUNITY · NEXT STEP回顾 · 社区 · 下一步

Take the Workflow Home

把今天的流程带回家

Today今天Built-in browser → co-browser Skill → a workflow you locked yourself内置浏览器 → co-browser Skill → 你亲手固定下来的流程

This week本周Re-run your Skill on a new input; stop on anything unexpected换一份输入重跑你的 Skill，遇到意外就停下来

Docs文档docs.connectonion.com

Community社区discord.gg/4xfD9k8AUF — share your first workflowdiscord.gg/4xfD9k8AUF——把你的第一个流程发出来

AI executes. You control the final step.AI 执行，你掌控最后一步。

Let AI RunYourLinkedIn

Know the Room First

Complete a LinkedIn Engage

Agent, Skill, and Tool

Try the Built-in Browser

LinkedIn Detects the Browser

Install Your Agent

One copy. One paste.复制一次，粘贴一次。

Your Agent’s First Email

Two Skills: Browser + Email

Two copies. Two pastes.复制两次，粘贴两次。

Run Your First External Skill

Create Your First Skill

Explore First, Then Lock the Flow

Explore a New Flow探索新流程

Lock a Repeatable Flow固定可复用流程

Add Capabilities After It Works

Automate Only After It Is Stable

Prepare Overnight夜间准备

Review in Daylight白天确认

Pair Your Phone in One Minute

The Computer Still Does the Work

Phone sends手机发送

Computer provides电脑提供

Connect Your Own Email

Take the Workflow Home

Let AI Run
Your
LinkedIn