# TinyFish, now on CoreSpeed (/blog/tinyfish-on-corespeed)

**CoreSpeed × TinyFish**

TinyFish brings web work to every agent, via CoreSpeed: your agents → CoreSpeed MCP → TinyFish (web agents, search, sign-ins, monitors).

A team dinner sounds like one task. In practice, it spans a restaurant's booking page, a guest's LinkedIn inbox, your team's Slack, and the details you want to remember next time. CoreSpeed and TinyFish let your agent work across those boundaries through one connection.

You choose which accounts to connect and which sites to sign in to. Existing site access and your agent client's permissions still apply.

## Web work and app work, in one agent \[#web-work-and-app-work-in-one-agent]

CoreSpeed gives the agent access to your connected accounts, tools and saved memory. TinyFish handles the work that lives on websites: finding information, navigating pages and completing authorized interactions. The agent can combine that web work with app tools from CoreSpeed, then carry the result into the next step.

TinyFish does much more than get past a sign-in page. It researches a question on the live web and writes up what it found, with sources. It gathers the same facts from several sites at once, one run per site. Where a site has no API, or only a thin one, it opens the pages in a real browser, clicks and fills in forms. When a site needs your account, you can sign in once in a saved TinyFish profile, and later runs start from it. It can also watch a page or a topic on a schedule and report what changed.

CoreSpeed is the layer every agent shares. Your agent adds one MCP server, `https://api.corespeed.io/mcp`, and finds TinyFish there beside Slack, Gmail, Notion and the other apps you connected, with memory that any of your agents can read later. You paste your TinyFish API key into CoreSpeed once. CoreSpeed keeps it and makes each call, so the agent never holds it. The web work itself still runs on TinyFish, under your TinyFish account.

**Your agent calls CoreSpeed. CoreSpeed calls TinyFish.**

One MCP endpoint. The keys stay with CoreSpeed.

* **Any agent:** Claude Code, Codex, Cursor, OpenClaw, Hermes.
* **CoreSpeed** ([https://api.corespeed.io/mcp](https://api.corespeed.io/mcp)): connected accounts (keys and sign-ins, never in the agent), tools (every connection, one tool list), memory (shared by all your agents).
* **TinyFish**, under your key: web agents (start\_automations), research (start\_research), Search and Fetch (fetch\_urls), remote browsers (create\_browser\_session), saved sign-ins (use\_profile), monitors (create\_monitor).
* **And your other apps:** Slack, Gmail, Notion, Linear.

No agent talks to TinyFish directly. Each call goes through CoreSpeed, under the TinyFish key you connected.

## Plan a team dinner in one request \[#plan-a-team-dinner-in-one-request]

Here is that split at work. This is an illustrative example of the workflow, not a record of a confirmed booking. The restaurant and the guest are invented.

```text
Book a table for six near Union Square on
Thursday at 7:30. Send the details to Dana
on LinkedIn, post them in #team-dinner, and
remember where we went.
```

1. **Find a table.** TinyFish searches for restaurants nearby and reads their booking pages, with `tinyfish__search` and `tinyfish__fetch_urls`.
2. **Book it.** A TinyFish web agent opens the restaurant's booking page and makes the reservation you asked for, with `tinyfish__run_automation`. This run changes something on a real site, so CoreSpeed marks it as an action and your agent client can ask you first.
3. **Message the guest.** Once the booking is confirmed, a second TinyFish run starts from your saved LinkedIn profile and sends Dana the restaurant, the time and the party size.
4. **Tell the team.** At the same time, CoreSpeed's Slack connector posts the same details in #team-dinner, with `slack__post_message`. Steps 3 and 4 run in parallel, and neither waits for the other.
5. **Remember it.** `memory__remember` saves the restaurant, the time and who came. Next month, a different agent can find it with `memory__search_memory` and book the same place through the same TinyFish connection.

**One request, five steps, one connection** (illustrative, invented names)

Request to Claude Code: "Book a table for six near Union Square on Thursday at 7:30. Send the details to Dana on LinkedIn, post them in #team-dinner, and remember where we went."

1. tinyfish\_\_search, tinyfish\_\_fetch\_urls — find a table nearby (TinyFish).
2. tinyfish\_\_run\_automation — book on the restaurant's page (TinyFish).
3. tinyfish\_\_run\_automation — message Dana, signed in (TinyFish, saved sign-in). Runs at the same time as step 4.
4. slack\_\_post\_message — post in #team-dinner (CoreSpeed's Slack connection). Runs at the same time as step 3.
5. memory\_\_remember — keep it for next time (CoreSpeed memory).

Step 3 starts signed in because of one earlier sign-in: the first run stopped at LinkedIn's sign-in page; you signed in once, yourself, in a TinyFish profile; runs since start signed in.

The booking, the LinkedIn message and the Slack post carry the same fields: Fernway Kitchen, Thursday 7:30 pm, party of 6. An illustration of how the tools fit together, not a recorded run.

The web still has rules. A site can block automated browsers or forbid them in its terms, and a saved sign-in lasts only as long as the site's session. When a run cannot finish, it stops and says why, and your agent tells you. Use TinyFish on sites and accounts you are allowed to automate.

## Set it up in a few minutes \[#set-it-up-in-a-few-minutes]

1. **Add CoreSpeed to your agent.** In Claude Code, Codex, Cursor, OpenClaw or Hermes, give the agent one line:

   ```text
   set up https://corespeed.io/SKILL.md
   ```

   The agent reads [the skill](/blog/what-is-skill-md-and-the-one-line-setup), adds the CoreSpeed MCP server and signs you in in the browser. In the Claude app and ChatGPT, add CoreSpeed as a custom connector. The [MCP server docs](/docs/mcp) show each client's entry.

2. **Create a TinyFish API key** at [agent.tinyfish.ai/api-keys](https://agent.tinyfish.ai/api-keys).

3. **Connect TinyFish.** On the [Connectors page](https://app.corespeed.io/connectors), find TinyFish, choose **Connect** and paste the key. Keep the connection private, or share it with your organization.

4. **Save a sign-in, if you need one.** For a site that needs your account, open **Browser Context Profiles** in TinyFish, sign in once in the setup browser, and save. Runs started with `use_profile` begin from that profile.

TinyFish bills its usage to your TinyFish account.

## Switch agents, keep your setup \[#switch-agents-keep-your-setup]

**Switch agents, keep your setup**

The agent changes. What it reaches through CoreSpeed does not.

* This week: Claude Code. Next month: Codex. Any time after: Cursor.
* The same CoreSpeed account keeps the connections (TinyFish, Slack, Gmail), the tools (tinyfish\_\_*, slack\_\_*, memory\_\_\*) and the memory ("Team dinner: Fernway Kitchen, Thursday 7:30, party of 6").

Reuses connected accounts, tools and saved CoreSpeed memory. Does not transfer an agent's chat history or in-progress execution state.

This week, the dinner request comes from Claude Code. Next month, someone on the team prefers Codex, Cursor or another compatible agent. They add CoreSpeed to that agent once, and the TinyFish connection, Slack, Gmail, the same tools and the saved memory are already there. Nobody pastes the TinyFish key again.

This reuses connected accounts, tools and saved CoreSpeed memory. It does not automatically transfer an agent's chat history or in-progress execution state. Each client still connects on its own, and its permission prompts still apply.

Agents come and go. Your connections, your tools and your memory stay in one place, ready for the next one.