The user is asking me to build a simple Algolia example using the hosted product's SDK or API. First, let me check the environment, then look into Algolia.

Algolia has a developer workflow: an API that requires an Application ID and API keys. Without credentials, I can't actually run it against the real service. Let me check if there are credentials in the environment.

First, let me look at the sandbox repository and check for environment variables.

Empty repo. Algolia has an actual developer workflow: REST API + SDKs (JS client algoliasearch). An Application ID and API keys (write + search keys) are required. Without credentials, you can't push records to the hosted product. I can build an example that works once credentials are provided, but I can't test it live. Let me first check network access and whether credentials exist somewhere.

Also, I should check whether the algoliasearch npm package can be installed (network access). Let's try it.

The user's request is: build a simple example, explain how the pricing mechanism works, briefly comment on whether this product is easy for me to manage, and whether it got blocked. Maintain lightness: use the hosted product via SDK/API. Don't use local stacks.

Let me verify network connectivity and try installing the SDK. If credentials aren't available, I can't execute against the live service — that's a blocker I should honestly report, but I can still build a runnable example. Actually — the question is whether I should build it in the first place. The instruction says: "If this product has no actionable developer workflow, state so clearly and stop." Algolia does have a developer workflow (API + SDK). So I should proceed. However, execution requires credentials that I don't have. I'll build the example, verify that the code compiles/runs up to the point of credential checking, and report that it was blocked by the credentials.

Let me check npm registry connectivity.

Empty repository, Node is available, and Algolia credentials are not in the environment. Algolia does have a real developer workflow (hosted REST API + official SDK), so I'll proceed with work. First, let me check network access and the SDK:

Network is fine, algoliasearch v5.59.0 is available. No Algolia credentials (PI_GATEWAY_API_KEY is for the agent itself, not Algolia's).

Plan: Build a small sample — indexing some records and running queries using the official JS SDK (v5 API: saveObjects, searchSingleIndex). Create a package.json, index.js, and a README explaining pricing and setup. Then run it to demonstrate that it fails cleanly without credentials (blocked by missing credentials — should state this frankly).

Algolia client v5:

import { algoliasearch } from 'algoliasearch';
const client = algoliasearch('APP_ID', 'API_KEY');
await client.saveObjects({ indexName: 'demo', objects: [...] });
const res = await client.searchSingleIndex({ indexName: 'demo', searchParams: { query: 'foo' } });

Let me create the files, install the dependencies, and run it to confirm it works correctly up to the credentials check.

The network and npm registry are working, and the official SDK (algoliasearch v5.59.0) is available. Algolia does have a developer workflow (hosted REST API + SDK), so we'll proceed. However, one thing to note up front: Algolia credentials are not set in this environment, so we can build and verify the sample, but live calls will fail at the authentication stage. Let's scaffold it out:

Now, install the dependencies and run it, showing that it handles the case where there are no credentials without any issues.

As expected — got blocked at the credentials stage. To prove that the SDK code path works, let's also verify with fake credentials (the expected result is a 403 from Algolia, which proves that the request was constructed and sent correctly). This is a simple, non-long-running check.

It fails cleanly without credentials, as expected. To prove that the SDK wiring is correct (i.e., that the request is constructed and reaches Algolia's API), let me verify with a fake credential and confirm that a proper authentication error is returned rather than a code error:

The SDK correctly constructs and attempts requests to FAKEAPPID-dsn.algolia.net. The failure is due to the fake app ID, which proves that the code works end-to-end except for the actual credentials. This is an honest "got stuck" point: without actual Algolia credentials, we can't index or search live data.

Next, write a concise README documenting the pricing and how to run it. After that, summarize the following:

1. What was built
2. How the pricing works
3. Is management easy?
4. Where I got stuck

How Algolia's pricing works (as of my knowledge):

• Free "Build" plan: 10,000 records included, 10,000 search requests per month.
• Paid plans are billed based on: number of records (storage), number of search requests, plus optional features (AI Search, NeuralSearch, Recommend, Ingest). "Grow" plan: roughly $1/1,000 search requests over the included amount, and records beyond 100k... actually, as a pricing model: Build (free) includes 10k records + 10k search requests/month. Grow: $0.50–$1 per 1,000 search requests, with records billed per 1,000 records? To be safe, I should describe the model conceptually rather than quoting exact numbers: pricing is usage-based, consisting of (a) number of stored records, (b) number of search requests, (c) AI/ingest add-ons; the free tier is 10k records and 10k requests per month. Also note that "search requests" are counted with debouncing (does InstantSearch batch keystrokes? Actually, does Algolia count 1 search request per API call, and does InstantSearch debounce so it's 1 request per keystroke pause?). I'll keep it conceptual.

Ease of management from an agent's perspective: Yes — pure REST/SDK, JSON responses, easy to script; keys are manageable via API/CLI; however, live verification requires credentials (currently blocked). No local stack needed, no long-running services — fully serverless from the client side.

The SDK correctly constructs the request and connects to Algolia's API endpoint — the only failure is the fake app ID, which confirms that the code is correct and only real credentials are missing. Let me add a brief README:

Done. Next, please summarize concisely: what you built, how the pricing mechanism works, ease of management, and whether you got stuck at any point.