Quickstart

Note - API is not currently live yet. More details will be published soon.

Right now, the Archer Protocol Portal is under construction. Once this portal is live, you will be able to generate an API key of your own in order to engage with the platform and deploy execution logic.

The better your plugins adhere to the protocol's standards (to be further outlined in this documentation) and the more that users are attracted to your plugins - the more likely your plugin is to be recommended to users who want to do things relevant to that plugin.

Note about API Status:

Please be aware that the API is not yet officially live. You can review the quickstart guide below to get acquainted with how the development process would look like once it is live in the near future.

Quickstart Guide

The Archer API provides a streamlined way for developers to create and deploy plugins that interact with user intents. Below is an overview of the high-level functions required to get started.

By leveraging Archer's API, you can expose your agent interfaces or execution flows directly to users via the Archer super-agent platform. This enables seamless routing of intents to your solution while monetizing through a simple fee-based structure. Users on Archer will already have a multichain wallet tied to their account that will be able to sign - with the user's consent - for transactions and intents that occur within your chain, protocol, intent, or agentic interface. That wallet object will be accessible to you as soon as users consent to using your agent.

Key Features

• Expose Your Agent Interface: Connect your custom execution flows or APIs to the Archer platform.

• Interact with User Objects: Access user data securely to personalize and optimize execution paths.

• Monetize Your Plugin: Define fees for intents routed through your plugin, earning revenue based on usage.

High-Level Functions

Here’s an example of how you can deploy a new plugin using our TypeScript API. These functions allow you to expose an endpoint, process user intents, and return actionable results.

1. registerPlugin()

Registers your plugin with the Archer backend, making it discoverable by the super-agent interface.

function registerPlugin(pluginName: string, endpointUrl: string): void {
  // Registers the plugin with its name and endpoint URL
  console.log(`Plugin "${pluginName}" registered at ${endpointUrl}`);
}

Parameters:

• pluginName: A unique name for your plugin (e.g., "MyAgent").

• endpointUrl: The URL where your agent interface or API can be accessed.

2. processIntent()

Handles incoming user intents routed by Archer and executes the corresponding logic.

async function processIntent(user: UserObject, intent: string): Promise<ExecutionResult> {
  // Process the user's intent and return execution results
  const { wallet_id, username } = user;
  console.log(`Processing intent "${intent}" for user ${username} (${wallet_id})`);
  
  // Example logic
  const result = await executeIntent(intent);
  return result;
}

Parameters:

• user: The User Object containing properties such as wallet_id, username, and optional tags.

• intent: A natural language command or query issued by the user (e.g., "Swap 10 ETH for USDC").

Returns:

• An ExecutionResult object containing details of the completed action (e.g., transaction ID, status).

3. setFeeStructure()

Defines fees for intents routed through your plugin, enabling monetization.

function setFeeStructure(pluginName: string, feeAmount: number): void {
  // Set a fee structure for your plugin
  console.log(`Fee structure set for plugin "${pluginName}": ${feeAmount} per intent`);
}

Parameters:

• pluginName: The name of your registered plugin.

• feeAmount: The fee (in native token or stablecoin) charged per successful execution of an intent routed through your plugin.

Example Workflow

1. Register Your Plugin: Use registerPlugin() to expose your agent interface or API endpoint to Archer.

2. Process Intents: Implement processIntent() to handle incoming commands from users securely and efficiently.

3. Monetize Your Plugin: Use setFeeStructure() to define fees for successful routing and execution of intents.

User Object Structure

The User Object is passed as a parameter in relevant API calls to provide context about the user interacting with your plugin.

interface UserObject {
  wallet_id: string;       // Unique identifier for the user's non-custodial wallet
  username: string;        // Username associated with the wallet
  tags?: string[];         // Optional metadata tags (e.g., "VIP", "DeFi Enthusiast")
}