How to Run an AI REST API Agent with OE Runtime

Call any REST API with natural language. OE Runtime connects to external APIs via HTTP, makes GET and POST requests, processes the JSON responses, and returns structured summaries — no Postman, no custom scripts, just a YAML file.

What You Need

• Node.js 18+ installed, or the OE Runtime binary from openenthrium.com/runtime
• An API key from OpenAI, Anthropic, or any supported LLM provider
• A REST API endpoint to call — any public or private HTTP API works
• A text editor — nothing else

Create the Project Folder

Create a folder called rest-api/ and add these two files:

The Skill Files

Create SKILL.md inside a rest-api/ directory. This is the portable skill — it follows the agentskills.io format and runs unchanged on Claude, Cursor, Windsurf, or OE Runtime:

---
name: rest-api
description: Make HTTP requests to a REST API and summarize responses
license: Apache-2.0
metadata:
  author: Open Enthrium
  version: "1.0"
---

You are an API integration agent. Make GET, POST, PUT, or DELETE requests
to external APIs and process the responses. Return structured summaries.
Complete all steps fully before writing your report.

## Step 1: Probe API
Make a GET request to /users to fetch a list of user records.
Also make a GET request to /posts to fetch a list of posts.
Note the HTTP status code, response time, and top-level structure of each response.

## Step 2: Fetch Detail and Create Record
Fetch the detail for user ID 1 via GET /users/1.
Then create a test post via POST /posts with body:
  { "title": "API Test Post", "body": "Created by OE Runtime agent.", "userId": 1 }
Note the response status and the ID assigned to the new post.

## Step 3: Report
Summarize API activity:
- Endpoints called and HTTP status codes
- Users endpoint: record count and field schema
- Posts endpoint: record count and field schema
- Detail fetch: user name and email for ID 1
- Created post: ID returned, confirmation of success

Create agent.yaml in the same directory to wire the skill to your connector:

name: API Caller
description: Make HTTP requests to a REST API and summarize responses
connectors:
  - connection_name: Target API
    connection_type: http
skills:
  - path: ./
    trigger_type: auto

The Config File

Create oe-config.json in the same directory:

{
  "llm": {
    "provider": "openai",
    "model": "gpt-4o",
    "apiKey": "YOUR_OPENAI_API_KEY"
  },
  "server": {
    "enabled": false,
    "port": 3333,
    "apiKey": "your-secret-api-key"
  },
  "connectors": [
    {
      "connection_name": "Target API",
      "connection_type": "http",
      "baseUrl": "https://jsonplaceholder.typicode.com"
    }
  ]
}

Replace the baseUrl with your target API and set the Authorization header with your API token. The agent supports any REST API that accepts JSON — Stripe, HubSpot, Salesforce, your own internal APIs, and more.

Download OE Runtime

Run the Agent

From the parent folder containing your skill directory:

1 npx recommended

npx -y @openenthrium/oe-runtime@latest ./rest-api

2 Windows

oe-runtime-win.exe ./rest-api

3 macOS

chmod +x oe-runtime-macos
./oe-runtime-macos ./rest-api

First run blocked? System Settings → Privacy & Security → Allow Anyway.

4 Linux

chmod +x oe-runtime-linux
./oe-runtime-linux ./rest-api

5 API Server integration

Add a "server" block to oe-config.json, then start with --serve:

{
  "llm": { ... },
  "server": { "enabled": true, "port": 3333, "apiKey": "your-secret-key" },
  "connectors": [ ... ]
}

npx -y @openenthrium/oe-runtime@latest --serve --config oe-config.json

Run with inline YAML:

curl -X POST http://localhost:3333/run \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your-secret-key" \
  -d '{"yaml": "...", "params": {}}'

Or run from a file on the server:

curl -X POST http://localhost:3333/run-file \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your-secret-key" \
  -d '{"file": "/path/to/agent.yaml", "params": {}}'

Use Cases

• Third-party API integration testing — Verify that a third-party API is returning the expected data shapes, status codes, and response times before integrating it into your application. The agent runs a suite of probe requests and surfaces any schema changes or degraded response times without writing test code.
• CRM data operations — Create, read, and update records in CRM systems like HubSpot, Salesforce, or Pipedrive via their REST APIs without logging into the platform. The agent translates plain English instructions into the correct API calls and confirms the result.
• Payment gateway integration — Call Stripe, PayPal, or Braintree APIs to fetch transaction records, refund payments, or retrieve subscription status for specific customers. The agent handles the authentication headers and request formatting automatically.
• Internal microservices orchestration — Coordinate calls across multiple internal REST API microservices to complete a business workflow without writing a dedicated orchestration layer. The agent sequences the calls, passes outputs from one service as inputs to the next, and produces a consolidated result.
• API health monitoring — Run the agent on a schedule to probe your production API endpoints and verify that they are returning 200 status codes with the expected response structure. Surface degraded endpoints in a report before your users notice the problem.
• Data synchronisation between systems — Fetch records from one REST API and create or update corresponding records in another. For example, pull new leads from a web form API and create contact records in your CRM without building a custom integration pipeline.
• Webhook payload testing — Send test POST payloads to your webhook endpoints to verify that they process different event types correctly and return the right status codes. This is faster and more repeatable than manually triggering events in a third-party system.
• E-commerce operations — Query your Shopify or WooCommerce REST API to fetch order details, update inventory levels, or trigger fulfilment actions. The agent can process a batch of orders, check stock availability across products, and generate a fulfilment report in a single run.