Skip to main content

​
Quickstart

This guide walks you through setting up a product, configuring adapters, and deploying your first autonomous agent.

​
Key Concepts

Before diving in, here’s how Bedrock is structured:
  • Product — Your application’s configuration: system prompt, LLM keys, adapters, and API keys. Think of it as a template.
  • Agent — A running instance of your product, deployed as a standalone autonomous AI. Each agent has its own memory, contacts, and state.
  • Adapter — An integration module (SMS, Email, Browser, etc.) that gives agents tools to interact with the world.
For example: you’d create a “Personal Assistant” product, then deploy a new agent for each user who signs up.

​
Step 1: Sign Up

Go to bedrock.orinlabs.org/signup and create your account. You’ll need:
  • An organization name (your company or project)
  • An email and password
After signing up, you’ll be taken to the Products page.

​
Step 2: Create a Product

From the Products page, click + New Product. Give it a name (e.g., “Personal Assistant”) and click Create.
Products page with a product created
You’ll land on the Product Detail page, which has three tabs: Settings, Adapters, and Agents.

​
Step 3: Configure Your Product

On the Settings tab, configure:
Product settings tab showing name, system prompt, model, and API keys
  1. System Prompt — The base instructions for all agents created under this product. This defines your agent’s personality and behavior.
  2. Default Model — The LLM model new agents will use (e.g., claude-sonnet-4, gpt-4o).
  3. LLM Provider Keys — Add your Anthropic API Key and/or OpenAI API Key. Bedrock uses these to make LLM calls on behalf of your agents.
  4. Create an API Key — Scroll to the Bedrock API Keys section and click Create API Key. Give it a name (e.g., “Production”) and copy the key immediately — it’s only shown once.
Click Save to persist your changes.
Copy your API key immediately after creating it. You won’t be able to see it again.

​
Step 4: Add Adapters

Switch to the Adapters tab. You’ll see a list of all available adapters with checkboxes. Click an adapter to add it to your product.
Product adapters tab showing available adapters
Adapters that don’t require configuration (like Contacts, Projects, Documents, Notifications) are added instantly. Adapters that require configuration (like SMS, Email, Computer) will prompt you to fill in their settings when you add them. For example:
  • SMS requires a Twilio phone_number (and optionally twilio_account_sid / twilio_auth_token)
  • Email requires an agentmail_domain (and optionally agentmail_api_key)
After adding adapters, click Save on the product page.
For a basic setup, start with Contacts, Notifications, Projects, and Documents — these require no configuration.

​
Step 5: Deploy an Agent

Now it’s time to deploy an agent. Agents are instances of your product — each one gets its own memory, contacts, and state. You can see and manage agents from the Agents tab:
Product agents tab showing agent list
Use the API to create an agent. This is typically done programmatically (e.g., when a new user signs up for your app): 
curl -X POST https://api.bedrock.orinlabs.org/api/cloud/agents/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Alice'\''s Assistant",
    "model": "claude-sonnet-4",
    "timezone": "America/New_York"
  }'
The agent inherits all adapters and settings from its product. You can also create agents from the portal by going to the Agents tab and clicking Create Agent.
You can override the product’s adapters for a specific agent by passing an adapters array with adapter names or IDs.

​
Step 6: Run the Agent

Wake the agent to start its autonomous loop: 
curl -X POST https://api.bedrock.orinlabs.org/api/cloud/agents/AGENT_ID/run/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"wakeup": true}'
The agent will:
  1. Check its notifications and tools for new information
  2. Take any necessary actions (send messages, create projects, etc.)
  3. Sleep when there’s nothing to do
  4. Automatically wake when new messages arrive or at its scheduled time

​
Step 7: Send Messages to the Agent

Inject messages into the agent’s memory to give it work: 
curl -X POST https://api.bedrock.orinlabs.org/api/memory/agents/AGENT_ID/log-messages/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Create a project called Q1 Planning that runs from March 1 to March 31."}
    ]
  }'
Then wake the agent to process it: 
curl -X POST https://api.bedrock.orinlabs.org/api/cloud/agents/AGENT_ID/run/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"wakeup": true}'

​
Step 8: Monitor with Traces

See exactly what the agent did: 
curl -X GET "https://api.bedrock.orinlabs.org/api/tracing/traces/list/?agent=AGENT_ID&limit=5" \
  -H "Authorization: Bearer YOUR_API_KEY"
Get detailed spans for a specific trace: 
curl -X GET https://api.bedrock.orinlabs.org/api/tracing/traces/TRACE_ID/ \
  -H "Authorization: Bearer YOUR_API_KEY"

​
What’s Next?

Configure SMS

Set up Twilio to send/receive text messages

Custom Adapters

Connect agents to your own APIs

Understand Memory

Learn how agents maintain context

Track Usage

Monitor costs and debug issues

​
Complete Example

Here’s a full Python script that creates a product, deploys an agent, and runs it: 
import requests
import time

API_KEY = "your-bedrock-api-key"
BASE_URL = "https://api.bedrock.orinlabs.org"
headers = {"Authorization": f"Bearer {API_KEY}"}

# 1. Deploy a new agent (product is already configured in the portal)
agent = requests.post(
    f"{BASE_URL}/api/cloud/agents/",
    headers=headers,
    json={
        "name": "Alice's Assistant",
        "model": "claude-sonnet-4",
        "timezone": "America/New_York",
    }
).json()
print(f"Created agent: {agent['id']}")

# 2. Send it a message
requests.post(
    f"{BASE_URL}/api/memory/agents/{agent['id']}/log-messages/",
    headers=headers,
    json={
        "messages": [
            {"role": "user", "content": "Create a project for Q1 planning, March 1-31."}
        ]
    }
)
print("Logged message to memory")

# 3. Run the agent
requests.post(
    f"{BASE_URL}/api/cloud/agents/{agent['id']}/run/",
    headers=headers,
    json={"wakeup": True}
)
print("Agent started running...")

# 4. Wait and check status
time.sleep(10)
status = requests.get(
    f"{BASE_URL}/api/cloud/agents/{agent['id']}/",
    headers=headers
).json()
print(f"Agent status: {status['status']}")

# 5. View traces
traces = requests.get(
    f"{BASE_URL}/api/tracing/traces/list/",
    headers=headers,
    params={"agent": agent["id"], "limit": 1}
).json()

if traces["results"]:
    trace_id = traces["results"][0]["id"]
    trace = requests.get(
        f"{BASE_URL}/api/tracing/traces/{trace_id}/",
        headers=headers
    ).json()
    print(f"\nTrace has {len(trace['spans'])} spans:")
    for span in trace["spans"][:5]:
        print(f"  - {span['name']} ({span['span_type']})")