> For the complete documentation index, see [llms.txt](https://docs.slinky.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.slinky.network/core-concepts/the-slinkylayer-tool-network.md).

# The SlinkyLayer tool network

SlinkyLayer provides one private interface for working with AI models and specialist tools. A user can begin with an ordinary question, then bring in live web search, research, market data, blockchain data or another capability when the task requires it.

The tool network is designed to grow without making the interface more complicated. New services can be added behind the same conversation instead of asking users to create another account, purchase another subscription or manage another API key.

### How it works

A question does not automatically go to every available tool. SlinkyLayer first determines whether an external capability is needed and selects a suitable resource from the network.

For a tool-assisted request, SlinkyLayer:

1. Identifies the capability required by the task.
2. Prepares a focused request for the selected tool.
3. Removes unrelated conversation history and identity information by default.
4. Routes the outbound request through Tor.
5. Presents any x402 payment requirement.
6. Runs the tool after payment or authorization is approved.
7. Returns the result to the original conversation.

The selected tool receives the information it needs to complete its assignment. It does not receive the full conversation by default.

For example, a market-data provider may need an asset symbol, quote currency and time range. It does not need unrelated messages about another asset, the user's broader investment thesis or an earlier research conversation.

### Available capabilities

The network is not limited to a fixed set of providers. Tools may be added, updated or removed as the product develops.

Current capability areas include:

| Capability         | Typical use                                                         |
| ------------------ | ------------------------------------------------------------------- |
| AI models          | Reasoning, writing, coding, analysis and synthesis                  |
| Live web           | Current reporting, announcements and primary sources                |
| Deep research      | Multi-source investigations, citations and evidence review          |
| Market data        | Prices, liquidity, volume, positioning and market activity          |
| Prediction markets | Probabilities, market disagreement and changing odds                |
| Blockchain data    | Wallet activity, token flows, governance and protocol state         |
| RWA intelligence   | Tokenized assets, issuers, yields and underlying markets            |
| Agents             | Monitoring, automation and multi-step workflows                     |
| Execution          | Preparing orders, transactions, alerts and other authorized actions |

These categories describe the network rather than a permanent list of products. The live discovery document is the source to use when checking what is currently available.

### Live tool discovery

The current tool catalog is published at:

[Open the live SlinkyLayer tool catalog](https://x402.slinkylayer.ai/.well-known/x402)

```
https://x402.slinkylayer.ai/.well-known/x402
```

The discovery document is machine-readable. Opening it in a browser will normally display JSON rather than a visual tool directory.

Users who prefer a visual interface can browse the available tools here:

[Explore tools in the SlinkyLayer app](https://app.slinkylayer.ai/apis)

### Why the catalog is discovered live

A copied list becomes outdated as soon as a resource changes. Prices, supported networks, request formats and availability can also change independently of the documentation.

Applications and agents should therefore read the discovery document when they need the current catalog. They should not rely on a list copied into source code or documentation.

A short-lived cache may be useful for performance, but clients should refresh it regularly and handle the possibility that a previously available resource has changed.

### Reading the catalog from a terminal

```bash
curl "https://x402.slinkylayer.ai/.well-known/x402"
```

To format the response when `jq` is installed:

```bash
curl --silent \
  "https://x402.slinkylayer.ai/.well-known/x402" |
  jq
```

### Reading the catalog with TypeScript

```typescript
const discoveryUrl =
  "https://x402.slinkylayer.ai/.well-known/x402";

async function getToolCatalog() {
  const response = await fetch(discoveryUrl, {
    headers: {
      Accept: "application/json",
    },
  });

  if (!response.ok) {
    throw new Error(
      `Unable to load tool catalog: ${response.status} ${response.statusText}`
    );
  }

  return response.json();
}

const catalog = await getToolCatalog();

console.dir(catalog, { depth: null });
```

Clients should inspect the returned document instead of assuming that every resource has the same request shape, price or payment requirements.

### Choosing a tool

Tool selection should be based on the job that needs to be completed. A request for current information may require live web search. A request about price or liquidity may require market data. A question involving wallet activity may require a blockchain data resource.

Some questions need more than one step. A research task might search current sources, compare market data and then use a model to organize the findings. Each tool should receive only the context required for its part of the task.

SlinkyLayer can keep the sequence inside one conversation, but the tools remain separate services. An output from one step may become input to the next without exposing the entire conversation to every provider.

### Payments through x402

Some tools are free to call, while others require payment. Paid resources use x402 to present a payment requirement as part of the HTTP request flow.

When a payment is required, the client can review the amount, asset, network and destination before authorizing it. After authorization, the request is repeated with the required payment information.

This makes it possible to pay for an individual request without opening an account or maintaining a subscription with each provider.

Payment does not grant broader permission. Paying for one request does not authorize another tool call, reveal more conversation history or approve an onchain action. Each paid or state-changing operation should be evaluated separately.

### Privacy across the network

Tor routing helps prevent downstream tools from receiving the user's direct IP address and network origin. Scoped requests also reduce the amount of conversation data shared with each provider.

These protections have practical limits. A selected tool must still receive the task information needed to produce a result. If a user asks about a named person, wallet or organization, that information may be part of the scoped request.

Public blockchain activity has its own visibility. Wallet addresses, transactions and other submitted actions may remain observable after they are published onchain. Tor routing does not make public blockchain records private.

SlinkyLayer is designed to reduce unnecessary disclosure. It does not claim that third-party computation or public blockchain activity becomes invisible.

### Building against a changing network

Developers and agents should treat the discovery document as live service data. A reliable integration should:

* Fetch or regularly refresh the catalog.
* Validate the selected resource before calling it.
* Read the current request requirements.
* Inspect the price before authorizing payment.
* Apply spending and network restrictions.
* Handle unavailable or changed resources.
* Set timeouts for external requests.
* Avoid automatically repeating a payment after an uncertain result.
* Require explicit approval before consequential actions.

The network is currently in Public Beta. Resource identifiers, request formats, pricing and supported capabilities may change as new tools are introduced.

### Using the network from SlinkyLayer

Most users do not need to call the discovery endpoint directly. They can ask a question in the SlinkyLayer chat and allow the interface to suggest an appropriate tool.

[Open SlinkyLayer chat](https://app.slinkylayer.ai/chat)

Before a paid tool runs, the interface can present the selected capability and its price. The result is then returned to the same conversation, keeping the research process in one place while limiting what is shared with each external provider.