> ## Documentation Index > Fetch the complete documentation index at: https://docs.hue.run/llms.txt > Use this file to discover all available pages before exploring further. > ## Agent Instructions > To set up Hue in an application, fetch https://docs.hue.run/guides/agent-setup.md and follow it. > Hue's project-data MCP server is https://mcp.hue.run/mcp. https://docs.hue.run/mcp only searches these docs and cannot read a Hue project. > Never ask the user to paste a Hue API key into chat; they store it as HUE_API_KEY themselves. > Install the exact SDK versions pinned on the page you're following, or on https://docs.hue.run/quickstart.md. Run the latest CLI without a project install as `npx -y @hue-run/sdk@latest`. In a project with `@hue-run/sdk` installed, use `npx hue`. Pin an exact version for reproducible CI runs. > Use Hue product terms: eval set, case, evaluator, run and scoring run. Older APIs may say dataset, scorer or experiment; prefer the current SDK methods. See https://docs.hue.run/concepts.md. # Run outreach practice on LinkedIn and X > Let a computer-use agent practice cold outreach on Hue's LinkedIn and X while you play the prospects through the Hue MCP. A computer-use agent practices cold outreach on Hue's LinkedIn and X: it finds a prospect, connects or follows, waits for the answer, messages them and keeps the conversation going. The agent drives the sites' own pages through a browser; an orchestrator plays everyone else through the tools below. Every person and company in the starters is fictional. A connection lists production reads by default: `?toolsets=outreach` on the [Hue MCP](https://docs.hue.run/agents/mcp-server.md) URL lists these tools, or call each through `execute_hue_tool` (reads) and `execute_hue_write_tool` (writes), with the input schema `search_hue_tools` returns. Writes need **Read and write** access without `?read_only=true`. The Hue MCP also returns this guide through `load_hue_guide` with topic `outreach`. ## Start the Worlds 1. Each app is its own World: one made in Hue from the **LinkedIn outreach starter** or **X outreach starter** template, or one you published. `list_worlds` finds them; `get_world_definition` lists a World's `versions`, and the newest one's id is the `world_version_id` to start. A republished World has a new version id, so read it again rather than keeping one. 2. `start_instance` with that `world_version_id` and an `idempotency_key`, once per app. It returns the instance, its app URLs and `HUE_WORLD_TOKEN` once; `get_instance_connections` reads them again. `HUE_SIM_LINKEDIN_WEB_URL` and `HUE_SIM_TWITTER_WEB_URL` are the sites, each an alias host under the sim suffix of its gateway (`https://linkedin-com.sim.hue.run` and `https://x-com.sim.hue.run` for `https://app.hue.run`). 3. `list_world_people` lists the instance's people: how each relates to the agent's account (connected, invitation, follows, conversation), whether they answer on their own (`automatic`) or only through you (`manual`), and what waits on whom. People with something pending come first. ## Play the prospects * `act_as_person` makes one person act toward the agent's account: on LinkedIn `accept_invitation`, `ignore_invitation`, `send_message`, `comment`, `react`, `follow`, `send_invitation`, `view_profile`; on X `follow`, `send_message`, `reply`. The person becomes `manual` and stops answering on their own; `set_person_responses` switches them back to `automatic`. * `create_notification` gives the agent's account a notification, unread by default; `actor` is the person and `post` the post it is about, as each kind needs. * `patch_world_record` changes one record of the running instance, such as a person's headline, company or bio, so an existing member becomes the prospect. A LinkedIn member added this way has no connections, so the agent's search shows them as an out-of-network member it cannot open; updating an existing 2nd or 3rd-degree member keeps them reachable. Connections, invitations and messages change only through `act_as_person` or the agent's own actions. ## Time Every write the agent makes moves the World's clock one step: 300 seconds in both starters. Reads, page loads included, never move it. `get_world_clock` reports `now`, `step_seconds` and the steps used; `set_world_step` changes the step for the rest of the instance. * An `at` on `act_as_person` or `create_notification` is a World time (RFC 3339), so read `now` from `get_world_clock` first and add the delay to it. A later `at` schedules the act; `list_scheduled_events` lists what waits and `cancel_scheduled_event` removes one. * A due act lands at the agent's next write or at `advance_world_clock`, never on a page load. While the agent only reads (waiting for a reply), `advance_world_clock` with `by_seconds` or `to` releases what came due; it lists them in `released`, and the agent sees them on its next page load. ## The browser The agent's browser keeps the real addresses (`https://www.linkedin.com/feed/`, `https://x.com/home`) and every request to them is answered by the World, with `HUE_WORLD_TOKEN` added outside the page. Hue's repository has two references: `examples/flow-harness/browser-route.ts` installs Playwright routes on a browser context the harness controls, and `examples/sim-proxy` is a local proxy for a browser the harness cannot reach into. Both send the token only to the alias hosts of one gateway: `app.hue.run` with `*.sim.hue.run`, `staging.hue.run` with `*.sim.staging.hue.run`, `localhost` with `*.sim.localhost`. * Use a fresh browser profile for each run, with service workers blocked. * A page paints its frame first and fills it from the app's own requests, each answered from the World; a slow answer takes up to about 20 seconds. A page is ready once its content (the feed, the profile, the thread) shows. * A message is sent once it shows in the thread and the composer is empty; one still in the composer was not sent. * What another person did since the last page load shows after a reload or a navigation. ## Finish and grade `finish_instance` ends an instance. `get_instance_diff` and `list_instance_steps` show what the agent changed and every step, its own writes and your acts. A finished instance's evidence lists your World events (`act_as_person`, notifications, record patches, clock jumps) with their effects, in step order; an act scheduled for later shows only once the agent's next write or `advance_world_clock` releases it. `save_instance_case` saves a finished instance as a case pinned to its World version. Without `criteria_json`, on a LinkedIn or X copy it drafts one check per distinct outreach write the agent made (invite, follow, message, post, comment, react, repost) on people and posts the World started with, and returns the drafted checks with their result; your own acts and clock jumps are never drafted. A copy with no outreach write gets no drafted checks and the call says so; `criteria_json` (outcome criteria, `load_hue_guide` topic `author`) supplies them instead. `check_instance_case` scores a finished instance of the same World version against a case's checks. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.