# Agent37

```json
{
  "name": "Agent37",
  "slug": "agent37",
  "url": "https://composio.dev/toolkits/agent37",
  "markdown_url": "https://composio.dev/toolkits/agent37.md",
  "logo_url": "https://logos.composio.dev/api/agent37",
  "categories": [
    "developer tools & devops"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-11-20T05:31:23.801Z"
}
```

![Agent37 logo](https://logos.composio.dev/api/agent37)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Agent37 MCP or direct API to create sandboxes, run agents, schedule jobs, and monitor executions through natural language.

## Summary

Agent37 is a control API for managed agent sandboxes, templates, networking, and execution.
It gives teams built-in scheduling, observability, budgets, and workspace administration.

## Categories

- developer tools & devops

## Toolkit Details

- Tools: 60

## Images

- Logo: https://logos.composio.dev/api/agent37

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Agent37.
  - Setup:
    - Configure Api Key credentials for Agent37.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- Create a managed sandbox for testing
- Schedule a recurring Agent37 agent run
- Review recent sandbox execution logs

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `AGENT37_CONNECT_INTEGRATION` | Connect Integration | Start a managed OAuth connection for one toolkit on an Agent37 instance. This creates a pending connected account and returns a browser authorization URL; the agent can return the URL, but a human must complete OAuth outside this action. Afterwards, list connections and confirm the account is ACTIVE. |
| `AGENT37_CREATE_BILLING_TOP_UP` | Create Billing Top Up | Create a Stripe Checkout URL to fund the connected Agent37 workspace with a real payment. This call does not itself move money; payment occurs when a person opens and completes the returned payment-sensitive Checkout URL. Treat that URL as private; completion also saves the card and enables Agent37's default automatic top-up rule. |
| `AGENT37_CREATE_CRON` | Create Cron | Schedule a recurring Agent37 prompt on an instance using a five-field cron expression and IANA timezone. Each firing can wake the instance and incur compute or managed-service costs. |
| `AGENT37_CREATE_INSTANCE` | Create Instance | Create a persistent Agent37 sandbox from a template. This can start billable compute; use GET_BILLING first when cost or available balance is uncertain. If public_ports is provided, those ports are exposed permanently to the public internet with no authentication; use it only for services intended for unauthenticated access. |
| `AGENT37_CREATE_INSTANCE_BACKUP` | Create Instance Backup | Create a live, crash-consistent manual backup without pausing the instance. The call can take minutes, a client timeout does not cancel it, and creating a new manual backup replaces the previous manual restore point. |
| `AGENT37_CREATE_PUBLIC_PORT` | Create Public Port | Permanently expose one instance port at an unauthenticated HTTPS URL until the mapping is deleted. Anyone with the URL can reach the service, public traffic can wake the instance and keep compute billing active, and prefix URLs are guessable; put application authentication in front of sensitive services. |
| `AGENT37_CREATE_SIGNED_URL` | Create Signed URL | Create a time-limited authenticated browser URL for one port on an Agent37 instance without making the port permanently public. The returned URLs contain expiring credentials and must be handled as secrets. |
| `AGENT37_CREATE_TEMPLATE` | Create Template | Register a workspace template by copying and privately pinning a linux/amd64 registry image. This can take several minutes and stores a private image snapshot. |
| `AGENT37_CREATE_TEMPLATE_BUILD` | Create Template Build | Create an Agent37 cloud-build record and a one-hour presigned URL for uploading the gzipped build context. The returned upload URL is a bearer credential and must not be logged or shared. |
| `AGENT37_DELETE_CRON` | Delete Cron | Permanently delete one recurring Agent37 schedule from an instance. This destructive action cannot be undone. |
| `AGENT37_DELETE_DOMAIN` | Delete Domain | Permanently remove a custom domain, stop all routing under it within seconds, and release its full nameserver delegation from Agent37 DNS hosting. Custom-domain registration is a paid feature requiring $50 in cumulative workspace top-ups. This destructive operation acts once and does not affect agent37.app URLs. |
| `AGENT37_DELETE_INSTANCE` | Delete Instance | Permanently delete one Agent37 instance and its retained disk, stopping its billing. This destructive action cannot be undone. |
| `AGENT37_DELETE_MEMBER` | Delete Member | Destructively remove a person from the connected Agent37 workspace or revoke a pending invitation. Member access is revoked immediately, but resources they created and API keys they minted remain. Revoking an invitation makes its link unusable. This cannot remove the workspace's last admin. |
| `AGENT37_DELETE_PUBLIC_PORT` | Delete Public Port | Permanently delete one public-port mapping and revoke its unauthenticated URL within seconds. This destructive operation acts once; repeating it returns 404, and deleting it does not invalidate separately minted signed URLs. |
| `AGENT37_DELETE_SSH_KEY` | Delete SSH Key | Revoke one SSH key from every instance in the workspace. Revocation reaches running instances within about two minutes and blocks new logins, but an already-open SSH session continues until it exits; stop or restart affected instances when immediate session termination is required. |
| `AGENT37_DELETE_TEMPLATE` | Delete Template | Permanently delete a workspace template. This destructive action cannot be undone, although existing instances created from the template keep running. |
| `AGENT37_DISCONNECT_INTEGRATION` | Disconnect Integration | Permanently remove one connected app account from an Agent37 instance. The agent can no longer use that account; other connections are untouched. |
| `AGENT37_EXECUTE_COMMAND` | Execute Command | Run a shell command inside an instance, either waiting for stdout, stderr, and exit code or starting it in the background. |
| `AGENT37_FORK_INSTANCE` | Fork Instance | Create an independent instance by copying a source instance's image and disk. The source remains unchanged; the new instance has separate billing, budget, ID, URLs, and files and may start billable compute. |
| `AGENT37_GET_BILLING` | Get Billing | Read the connected workspace's wallet balance, numeric billing tier, memory and instance limits, automatic refill rule, and payment status. |
| `AGENT37_GET_CRON` | Get Cron | Get the complete configuration of one recurring schedule on an instance. |
| `AGENT37_GET_DOMAIN` | Get Domain | Read one custom domain's status and full nameserver delegation. Registration is a paid feature requiring $50 in cumulative workspace top-ups, the whole dedicated domain must use Agent37's nameservers, and active public-port mirrors are unauthenticated. |
| `AGENT37_GET_INSTANCE` | Get Instance | Get the configuration, resource allocation, URLs, and current lifecycle state of one instance. |
| `AGENT37_GET_INSTANCE_BUDGET` | Get Instance Budget | Read one instance's managed-service monthly cap, consumption, remaining allowance, and one-time credit balance in provider-native micros. |
| `AGENT37_GET_INSTANCE_EVENTS` | Get Instance Events | Read an Agent37 instance's start, sleep, wake, and stop history over an optional inclusive date window of at most 90 days. |
| `AGENT37_GET_INSTANCE_USAGE` | Get Instance Usage | Read one UTC month's managed-service spend for an Agent37 instance, broken down across language models, search, Composio, and paid tools. |
| `AGENT37_GET_TEMPLATE` | Get Template | Get one Agent37 template or pinned template revision, including its image, installed agents, entrypoint, defaults, and workspace revision history. |
| `AGENT37_GET_TEMPLATE_BUILD` | Get Template Build | Get a template build's current status, timestamps, failure details, and published template result. Polling a completed build can trigger final template registration. |
| `AGENT37_GET_TEMPLATE_BUILD_LOGS` | Get Template Build Logs | Read an incremental chunk of a template build's Docker output and return the next byte offset for tailing, together with current build status and failure details. |
| `AGENT37_GET_WORKSPACE_USAGE` | Get Workspace Usage | Read Agent37 workspace spend over an inclusive date window, with daily, instance, model, and integration breakdowns. Omit dates to use the provider's defaults. |
| `AGENT37_INVITE_MEMBER` | Invite Member | Send an email invitation to join the connected Agent37 workspace as an admin or user. This does not add the person immediately; they must accept the invitation. A workspace created through API signup must be funded before it can send member invitations. |
| `AGENT37_LIST_CRON_RUNS` | List Cron Runs | List the latest 50 firings of one Agent37 cron, newest first, including whether each turn started, its session ID, and any skip reason. |
| `AGENT37_LIST_CRONS` | List Crons | List all recurring Agent37 schedules on an instance, oldest first. |
| `AGENT37_LIST_DOMAINS` | List Domains | List the workspace's custom domains and the nameservers each dedicated domain must fully delegate to Agent37. Domain registration is a paid feature requiring $50 in cumulative workspace top-ups; active public-port mirrors remain unauthenticated. |
| `AGENT37_LIST_INSTANCE_BACKUPS` | List Instance Backups | List all retained automatic and manual restore points for an instance, newest first, including IDs, timestamps, and compressed sizes. |
| `AGENT37_LIST_INSTANCES` | List Instances | List all instances in the connected workspace, newest first, including their IDs, configuration, URLs, resource allocation, and lifecycle state. |
| `AGENT37_LIST_INTEGRATION_CONNECTIONS` | List Integration Connections | List app accounts attached to an Agent37 instance, optionally for one toolkit. Use status and statusReason to confirm whether a pending OAuth handoff became ACTIVE or failed. |
| `AGENT37_LIST_INTEGRATION_TOOLKITS` | List Integration Toolkits | Browse one cursor-paginated page of apps that can be connected to an Agent37 instance. Pass nextCursor back as cursor to continue. |
| `AGENT37_LIST_MEMBERS` | List Members | List all people in the connected Agent37 workspace and every pending email invitation, including IDs suitable for removal or invitation revocation. |
| `AGENT37_LIST_PUBLIC_PORTS` | List Public Ports | List an instance's permanent public HTTPS mappings. Every listed URL accepts traffic without Agent37 credentials and remains reachable until its mapping is deleted. |
| `AGENT37_LIST_SSH_KEYS` | List SSH Keys | Audit up to 20 SSH public-key fingerprints registered for workspace-wide access, newest first. Agent37 does not return public-key blobs or any private key material. |
| `AGENT37_LIST_TEMPLATES` | List Templates | List system and workspace templates that can be used to create an instance. |
| `AGENT37_READ_INSTANCE_LOGS` | Read Instance Logs | Read recent container output and compact runtime health for an instance without waking it. |
| `AGENT37_READ_INSTANCE_METRICS` | Read Instance Metrics | Read recent CPU, memory, and disk history and configured resource limits for an instance without waking it. |
| `AGENT37_REGISTER_DOMAIN` | Register Domain | Register a dedicated custom domain for the workspace. This paid feature requires at least $50 in cumulative workspace top-ups; registration requires ownership of a registrable domain and returns nameservers that must replace the domain's entire existing DNS delegation, so do not use a domain needed for a website, mail, or other records. |
| `AGENT37_REGISTER_SSH_KEY` | Register SSH Key | Register one OpenSSH public key for workspace-wide shell access. The key can authenticate to every current and future instance in the connected workspace, including root login, until revoked; register only a trusted public key and never submit private-key material. A workspace accepts at most 20 distinct fingerprints. |
| `AGENT37_RESIZE_INSTANCE` | Resize Instance | Change a running instance's CPU, memory, or disk while retaining its ID, URLs, and files. This recreates the container, loses in-memory state, changes billing immediately, and disk growth cannot be reversed. |
| `AGENT37_RESTORE_INSTANCE_BACKUP` | Restore Instance Backup | Destructively replace an instance's current disk data with a retained backup. Files written after the backup and in-memory state are permanently lost; create a backup first if the current state may be needed. Do not retry after a client timeout; poll the instance until it leaves updating. |
| `AGENT37_RUN_CRON_NOW` | Run Cron Now | Trigger one Agent37 cron immediately without changing its recurring schedule. This fire-and-forget action starts agent work and may incur compute or managed-service costs; a triggered response does not mean the work succeeded. |
| `AGENT37_SEND_FEEDBACK` | Send Feedback | Send external feedback to the Agent37 team about a bug, feature request, or documentation gap. A person at Agent37 reads the submitted message, but this endpoint sends no reply and is not a support channel. Do not include secrets or API keys. |
| `AGENT37_SET_INSTANCE_BUDGET` | Set Instance Budget | Replace an instance's monthly managed-service spending ceiling, effective immediately and for future UTC months. Raising this ceiling moves no funds, but authorizes the instance to consume more of the workspace wallet through managed LLM, Brave, Composio, and Perflo calls; inspect current budget, usage, and wallet balance before increasing it. |
| `AGENT37_SET_INSTANCE_POWER_STATE` | Set Instance Power State | Start, stop, sleep, or restart an instance. Starting or restarting can resume billable compute; sleeping checkpoints state and releases CPU and memory. |
| `AGENT37_SIGN_UP_WORKSPACE` | Sign Up Workspace | Create a separate Agent37 workspace, empty wallet, owner claim invitation, and full workspace API key. Every call creates a new workspace and the key is shown only once. The provider endpoint is unauthenticated, but this action is available through the connected API-key toolkit and uses its shared transport; Agent37 accepts or ignores the connected Authorization header. Immediately store the returned API key as a secret and disclose the single-use admin claim URL only to the intended owner. Signup itself charges nothing, but the payment-sensitive Checkout URL can make a real payment and must be shared only with the intended payer. |
| `AGENT37_START_TEMPLATE_BUILD` | Start Template Build | Start a template build after its gzipped context has been uploaded. Starting consumes that build record: it cannot be started twice, and a failed start may require creating and uploading a new build. |
| `AGENT37_TOP_UP_INSTANCE_BUDGET` | Top Up Instance Budget | Irreversibly add one-time managed-service spending headroom to an instance. This moves no funds, but the added allowance persists across months and can authorize additional charges against the workspace wallet. Supply an idempotency key before retrying after a timeout to avoid adding the allowance twice. |
| `AGENT37_UPDATE_CRON` | Update Cron | Change a recurring schedule's prompt, timing, agent, profile, name, timezone, or enabled state. Set enabled to false to pause future firings; enabling it resumes agent work, and each firing can wake the instance and incur compute or managed-service costs. |
| `AGENT37_UPDATE_INSTANCE_IMAGE` | Update Instance Image | Apply a template image to an instance while preserving its mounted disk. This irreversibly discards changes outside the mount path and recreates a running instance's container; read its logs first when repairing a failure. |
| `AGENT37_UPDATE_INSTANCE_SETTINGS` | Update Instance Settings | Update an instance's name, metadata, environment, auto-sleep, idle timeout, or outbound network policy without changing its image or compute size. |
| `AGENT37_UPDATE_TEMPLATE` | Update Template | Update a workspace template's name, image, description, default port, or entrypoint. Image or entrypoint changes publish a new revision; existing instances do not change automatically. |
| `AGENT37_VERIFY_DOMAIN` | Verify Domain | Check and nudge verification after replacing a registered dedicated domain's nameservers with those returned by REGISTER_DOMAIN. The paid custom-domain feature requires $50 in cumulative workspace top-ups before registration; verification is idempotent and may remain pending while full DNS delegation propagates. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to Agent37
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["agent37"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["agent37"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run Agent37 tools with your agent

Send a request, execute the Agent37 tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "Create a managed Agent37 sandbox named staging for testing a Python data-processing agent"}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Create a managed Agent37 sandbox named staging for testing a Python data-processing agent" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to Agent37 and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["agent37"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["agent37"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a Agent37 request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to Agent37 tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("Create a managed Agent37 sandbox named staging for testing a Python data-processing agent")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Create a managed Agent37 sandbox named staging for testing a Python data-processing agent",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native Agent37 Integration

- Supports both Agent37 MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable sandbox and agent operations
- Rich coverage for creating, running, scheduling, and querying Agent37 resources

### 2. Managed Auth

- Securely stores and uses your Agent37 API key without hard-coding it into agent prompts
- Central place to manage, scope, and revoke Agent37 access
- Per user and per environment credentials for safer agent deployments

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Agent37
- Scoped, least privilege access to Agent37 sandboxes, workspaces, and operations
- Full audit trail of agent actions to support review and compliance

## Use Agent37 with any AI Agent Framework

Choose a framework you want to connect Agent37 with:

- [ChatGPT](https://composio.dev/toolkits/agent37/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/agent37/framework/claude-cowork)

## Related Toolkits

- [Supabase](https://composio.dev/toolkits/supabase) - Supabase is an open-source backend platform offering scalable Postgres databases, authentication, storage, and real-time APIs. It lets developers build modern apps without managing infrastructure.
- [Codeinterpreter](https://composio.dev/toolkits/codeinterpreter) - Codeinterpreter is a Python-based coding environment with built-in data analysis and visualization. It lets you instantly run scripts, plot results, and prototype solutions inside supported platforms.
- [GitHub](https://composio.dev/toolkits/github) - GitHub is a code hosting platform for version control and collaborative software development. It streamlines project management, code review, and team workflows in one place.
- [1password](https://composio.dev/toolkits/_1password) - 1Password is a password manager and digital vault for storing logins, secrets, notes, and secure documents. It helps individuals and teams protect credentials, share access safely, and reduce password risk.
- [Ably](https://composio.dev/toolkits/ably) - Ably is a real-time messaging platform for live chat and data sync in modern apps. It offers global scale and rock-solid reliability for seamless, instant experiences.
- [Abuselpdb](https://composio.dev/toolkits/abuselpdb) - Abuselpdb is a central database for reporting and checking IPs linked to malicious online activity. Use it to quickly identify and report suspicious or abusive IP addresses.
- [Alchemy](https://composio.dev/toolkits/alchemy) - Alchemy is a blockchain development platform offering APIs and tools for Ethereum apps. It simplifies building and scaling Web3 projects with robust infrastructure.
- [Algolia](https://composio.dev/toolkits/algolia) - Algolia is a hosted search API that powers lightning-fast, relevant search experiences for web and mobile apps. It helps developers deliver instant, typo-tolerant, and scalable search without complex infrastructure.
- [Anakin](https://composio.dev/toolkits/anakin_io) - Anakin is a web automation platform offering scraping, crawling, search, and browser automation. Use it to extract structured data, automate site tasks, and monitor web changes reliably.
- [Anchor browser](https://composio.dev/toolkits/anchor_browser) - Anchor browser is a developer platform for AI-powered web automation. It transforms complex browser actions into easy API endpoints for streamlined web interaction.
- [AnyAPI](https://composio.dev/toolkits/anyapi) - AnyAPI is a marketplace of utility APIs for validation, currency conversion, holidays, documents, and web data. It brings common application workflows together through one practical API platform.
- [Apiflash](https://composio.dev/toolkits/apiflash) - Apiflash is a website screenshot API for programmatically capturing web pages. It delivers high-quality screenshots on demand for automation, monitoring, or reporting.
- [Apiverve](https://composio.dev/toolkits/apiverve) - Apiverve delivers a suite of powerful APIs that simplify integration for developers. It's designed for reliability and scalability so you can build faster, smarter applications without the integration headache.
- [Appcircle](https://composio.dev/toolkits/appcircle) - Appcircle is an enterprise-grade mobile CI/CD platform for building, testing, and publishing mobile apps. It streamlines mobile DevOps so teams ship faster and with more confidence.
- [Appdrag](https://composio.dev/toolkits/appdrag) - Appdrag is a cloud platform for building websites, APIs, and databases with drag-and-drop tools and code editing. It accelerates development and iteration by combining hosting, database management, and low-code features in one place.
- [Appveyor](https://composio.dev/toolkits/appveyor) - AppVeyor is a cloud-based continuous integration service for building, testing, and deploying applications. It helps developers automate and streamline their software delivery pipelines.
- [Authyo](https://composio.dev/toolkits/authyo) - Authyo is a REST API service for passwordless authentication, OTP verification, session management, and transactional notifications. Use it to add secure login flows and user verification without building auth infrastructure from scratch.
- [AWS Marketplace MCP](https://composio.dev/toolkits/aws_marketplace_mcp) - AWS Marketplace MCP provides MCP access to AWS Marketplace's cloud software, data, and services catalog. Use it to discover, compare, and evaluate 30K+ AWS Marketplace listings faster.
- [Azure Monitor Activity Log](https://composio.dev/toolkits/azure_monitor_activity_log) - Azure Monitor Activity Log is Azure's service that records management and control-plane events for a subscription. Use it to audit changes, troubleshoot issues, and track resource operations across your Azure resources.
- [Backendless](https://composio.dev/toolkits/backendless) - Backendless is a backend-as-a-service platform for mobile and web apps, offering database, file storage, user authentication, and APIs. It helps developers ship scalable applications faster without managing server infrastructure.

## Frequently Asked Questions

### Do I need my own developer credentials to use Agent37 with Composio?

Yes, Agent37 requires you to configure your own API key credentials. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)
