Build an Autonomous Topic Researcher with Exabase Workers

This is a walkthrough of the Topic Researcher example, which uses the Exabase Workers API to spin up agents that trawl the web for a given subject and save the best articles as bookmarks in an Exabase Base.

What it does

You type in a topic. The app creates a Worker (a background AI agent) that goes off and searches the web for it, picks out the 5 to 10 best articles, and saves them as bookmarks inside an Exabase Space. You can kick off the agent whenever you like, watch results come in as it finds them, and manage several researchers from one dashboard.

There's very little code here. The agent's behaviour is defined entirely by a natural language prompt. You tell it what to research, point it at a folder, and Exabase takes care of the rest: the web searching, the bookmark saving, the execution infrastructure. Nothing to deploy, nothing to keep running.

What are Exabase Workers?

Workers are AI agents that run inside your Exabase Bases. You describe a task in plain English, give the Worker access to specific resources, and it gets on with it. Workers can search the web, create bookmarks and notes, organise files, tag content, and manage tasks. They run on Exabase's infrastructure, so there's no server on your side.

How Exabase fits in

Setting up a Space for output

First the app creates a private Space (basically a folder) where the Worker will put its findings:

const space = await api.spaces.create(
  { name: `Research: ${topic}`, isPrivate: true },
  { baseId: baseId as string },
);
const spaceId = space.id as string;

const space = await api.spaces.create(
  { name: `Research: ${topic}`, isPrivate: true },
  { baseId: baseId as string },
);
const spaceId = space.id as string;

const space = await api.spaces.create(
  { name: `Research: ${topic}`, isPrivate: true },
  { baseId: baseId as string },
);
const spaceId = space.id as string;

Each Worker gets its own Space. Delete the Worker and the app tidies up the Space as well.

Creating a Worker

One API call. You pass a name, a prompt saying what the agent should do, and an accessResourceIds array that limits which folders it can touch:

const workerRes = await exabaseFetch(
  "/v2/workers",
  {
    method: "POST",
    body: JSON.stringify({
      name: `Topic Researcher: ${topic}`,
      prompt: `You are a topic researcher. Find the newest information and articles on the web about "${topic}". Save 5-10 of the best articles as exabase bookmarks.`,
      accessResourceIds: [spaceId],
    }),
  },
  baseId as string,
);

const workerRes = await exabaseFetch(
  "/v2/workers",
  {
    method: "POST",
    body: JSON.stringify({
      name: `Topic Researcher: ${topic}`,
      prompt: `You are a topic researcher. Find the newest information and articles on the web about "${topic}". Save 5-10 of the best articles as exabase bookmarks.`,
      accessResourceIds: [spaceId],
    }),
  },
  baseId as string,
);

const workerRes = await exabaseFetch(
  "/v2/workers",
  {
    method: "POST",
    body: JSON.stringify({
      name: `Topic Researcher: ${topic}`,
      prompt: `You are a topic researcher. Find the newest information and articles on the web about "${topic}". Save 5-10 of the best articles as exabase bookmarks.`,
      accessResourceIds: [spaceId],
    }),
  },
  baseId as string,
);

That prompt is the whole behaviour definition. Workers already know how to search the web and save bookmarks; you just say what to look for and where to put it.

accessResourceIds matters here because it stops different topic researchers from writing into each other's folders.

Running a Worker

Creating a Worker just defines it. A separate call kicks off the actual run:

const res = await exabaseFetch(
  `/v2/workers/${workerId}/run`,
  { method: "POST" },
  baseId as string,
);
const chatId = res.chatId;

const res = await exabaseFetch(
  `/v2/workers/${workerId}/run`,
  { method: "POST" },
  baseId as string,
);
const chatId = res.chatId;

const res = await exabaseFetch(
  `/v2/workers/${workerId}/run`,
  { method: "POST" },
  baseId as string,
);
const chatId = res.chatId;

You get back a chatId for tracking progress. The Worker runs in the background, so the app polls to find out when it's finished.

Checking progress

Every 7 seconds the app fetches the Worker's chat messages. If the last message is from the assistant, the run is done:

const res = await exabaseFetch(
  `/v2/workers/${workerId}/chats/${chatId}/messages`,
  { method: "GET" },
  baseId as string,
);

const messages = res.messages || [];
const lastMessage = messages[messages.length - 1];

return {
  isRunning: lastMessage?.role !== "assistant",
  messages: messages,
};

const res = await exabaseFetch(
  `/v2/workers/${workerId}/chats/${chatId}/messages`,
  { method: "GET" },
  baseId as string,
);

const messages = res.messages || [];
const lastMessage = messages[messages.length - 1];

return {
  isRunning: lastMessage?.role !== "assistant",
  messages: messages,
};

const res = await exabaseFetch(
  `/v2/workers/${workerId}/chats/${chatId}/messages`,
  { method: "GET" },
  baseId as string,
);

const messages = res.messages || [];
const lastMessage = messages[messages.length - 1];

return {
  isRunning: lastMessage?.role !== "assistant",
  messages: messages,
};

While it polls, the results panel refreshes too, so bookmarks appear as the Worker finds them.

Listing Workers

All your topic researchers show up in the sidebar. One GET:

const res = await exabaseFetch("/v2/workers", { method: "GET" });

const res = await exabaseFetch("/v2/workers", { method: "GET" });

const res = await exabaseFetch("/v2/workers", { method: "GET" });

Each Worker comes back with its id, name, createdAt, and accessResourceIds. The app uses accessResourceIds to load the right Space when you click on one.

Viewing results

After a run, the Worker's bookmarks and notes sit in its Space. The app pulls them with the SDK's resource filtering:

const res = await api.resources.filter({
  kind: ["bookmark", "notepad"],
  rootId: spaceId,
});

const res = await api.resources.filter({
  kind: ["bookmark", "notepad"],
  rootId: spaceId,
});

const res = await api.resources.filter({
  kind: ["bookmark", "notepad"],
  rootId: spaceId,
});

Bookmarks come with a title and URL, rendered as links you can click through to read.

Cleanup

Deleting a Worker also removes the Space it was writing to:

// Delete the worker
await exabaseFetch(
  `/v2/workers/${workerId}`,
  { method: "DELETE" },
  baseId as string,
);

// Delete the space it was attached to
await api.spaces.remove(
  { spaceId: workerSpaceId },
  { baseId: baseId as string },
);

// Delete the worker
await exabaseFetch(
  `/v2/workers/${workerId}`,
  { method: "DELETE" },
  baseId as string,
);

// Delete the space it was attached to
await api.spaces.remove(
  { spaceId: workerSpaceId },
  { baseId: baseId as string },
);

// Delete the worker
await exabaseFetch(
  `/v2/workers/${workerId}`,
  { method: "DELETE" },
  baseId as string,
);

// Delete the space it was attached to
await api.spaces.remove(
  { spaceId: workerSpaceId },
  { baseId: baseId as string },
);

You can also remove individual bookmarks without binning the whole Worker:

await exabaseFetch(
  "/v2/resources/delete",
  {
    method: "POST",
    body: JSON.stringify({
      resourceIds: [resourceId],
      archive: false,
    }),
  },
  baseId as string,
);

await exabaseFetch(
  "/v2/resources/delete",
  {
    method: "POST",
    body: JSON.stringify({
      resourceIds: [resourceId],
      archive: false,
    }),
  },
  baseId as string,
);

await exabaseFetch(
  "/v2/resources/delete",
  {
    method: "POST",
    body: JSON.stringify({
      resourceIds: [resourceId],
      archive: false,
    }),
  },
  baseId as string,
);

Key Exabase APIs used in this example

Technologies

• Exabase: Workers API for background agents, Spaces for organising output, Resources for browsing results

• Next.js: Front-end and back-end (Server Actions)

• shadcn/ui: UI components

• Tailwind CSS: Styling

• Biome: Lint and format

Run it yourself

git clone https://github.com/futurebrowser/exabase-examples.git
cd

git clone https://github.com/futurebrowser/exabase-examples.git
cd

git clone https://github.com/futurebrowser/exabase-examples.git
cd

Add EXABASE_API_KEY and EXABASE_BASE_ID to .env. Open http://localhost:3000, type a topic, and click Create Worker.

FAQ

How is this different from just calling an LLM with a tool?

You don't have to wire anything up. Workers already have web search, bookmark creation, note-taking, and file management built in. There's no tool schema to write, no execution loop to manage, no server to run. You write a prompt and the Worker does the job.

Can I run the same Worker more than once?

Yes. Each run is a fresh execution. The Worker searches again and might find different or newer articles. Results pile up in the same Space, so repeated runs build out the collection.

What else can Workers do?

Web search and bookmarking is just what this example uses. Workers can also create notes, organise files, tag content, and manage tasks. The prompt defines the behaviour, so what you can do with them is fairly open-ended.

Why bother with accessResourceIds?

Without it the Worker can access everything in the Base. Scoping it to a single Space keeps each topic researcher's output separate and stops agents from trampling on each other.

Could I adapt this for something besides web research?

Easily. The Workers API doesn't care what the task is. You could build Workers that organise existing resources, tag and categorise a backlog of content, maintain summary notes, or do periodic housekeeping. Same pattern: prompt, scoped access, run.