Agent Octo

Manage your life with Agentic AI. Connected. Controlled. Yours.

Agent Octo gives you a multi-tenant agent platform with runtime OpenAPI integrations, provider connections, channels, and a Rust-powered sandbox built for real operational control.

Explore Specs View GitHub

Runtime integrations, channels, and sandboxed execution in one stack

See the product in motion

Watch an agent workflow unfold as you scroll

Instead of a comparison grid, this section shows the operating model: inbound chat, agent reasoning, and a handoff into tools and people when the work needs it.

Telegram intake

A customer message becomes a structured task

5 steps

A customer says their order failed and they need help today.

Agent Octo classifies the issue, extracts the order reference, and opens the support workflow.

Can it keep the thread in Telegram instead of switching tools?

Yes. The response stays in-channel while the runtime prepares the next action in the background.

Urgent cases can be escalated to a human without losing the conversation context.

Runtime tools

The agent reaches into connected systems when it needs context

5 steps

Check the CRM record and see whether this account is priority support.

The OpenAPI tool spec is loaded at runtime and the account profile is fetched through an authenticated connection.

The record shows enterprise support, prior incidents, and the account owner.

Good. Route billing details to the right team and keep the reply concise.

The draft response is prepared and the ownership handoff is attached for review.

Human + agent operations

Automation handles the repeatable work while operators stay in control

5 steps

A new inbound lead asked for pricing, compliance details, and a live demo.

Agent Octo sends the right materials, records the lead, and flags the request for follow-up.

Can we stop it from sending the final offer automatically?

Yes. Sensitive steps can remain human-approved while the repetitive work stays automated.

That gives teams faster execution without giving up operational control.

What the platform already covers

This section mirrors the source page’s capabilities grid, but with Agent Octo’s actual product surface.

Multi-tenant by design

Run one deployment for multiple organizations, teams, or customers with scoped configuration.

Provider connections

Configure model providers and authenticated connections without rewriting the application.

OpenAPI integrations

Load tool definitions from Swagger/OpenAPI specs so agents can use external systems at runtime.

Channel delivery

Receive and send messages through Telegram today, with room to grow the channel surface.

Rust-powered sandbox

Use the Monty-based Python sandbox for code execution workloads that need stronger operational boundaries.

Code Mode support

Reduce token overhead by leaning on Code Mode patterns when tool execution is the better path.

How Agent Octo is wired

Like the source page’s systems section, this breaks the product down into a sequence and a few architectural guarantees.

1. Connect a channel
Start with Telegram or add more delivery paths over time.
2. Route into an org
Messages stay scoped to the correct organization, providers, and integrations.
3. Call tools and models
Agents can use provider connections, runtime integrations, and sandboxed code execution.
4. Ship the answer back
Responses return through the channel with the same operational boundaries you configured.

Typed backend

Axum, Rust on Nails, and generated database queries keep the core path explicit and testable.

Runtime integrations

OpenAPI specs can be loaded as integrations so the tool surface can change without recompiling the app.

Operational control

Multi-tenant org boundaries, provider setup, and channel routing are managed directly in the application.

Built around practical agent operations

The source page has a product-principles block. This version keeps that layout but shifts the copy to how Agent Octo is meant to be used.

Tools stay close to the work

Integrations are discoverable and lightweight in context so agents are not flooded with irrelevant tool definitions.

Sandboxing matters

The Rust-powered Python sandbox and Code Mode support are there to make code execution more practical and more controlled.

Configuration is productized

Providers, channels, and integrations are first-class application concepts instead of one-off scripts hidden in deployment glue.

Quick start

This follows the same broad placement as the setup section on the inspiration page, but grounded in the actual README flow for Agent Octo.

Start locally in a few steps

Download the deployment file and create your environment variables.
Add a Telegram bot token and your preferred model provider credentials.
Run `docker compose up`, then open the app and configure providers, integrations, and channels.

Good first configuration

One provider connection for your preferred LLM
One Telegram channel for ingress and egress
One OpenAPI integration the agent can call safely

Frequently asked questions

Who is Agent Octo for?

Teams that want to run an agent product themselves, especially when they need integrations, channels, and tenant isolation.

Do I have to hardcode every tool?

No. A core part of the model is loading integrations from OpenAPI specs so the available tool surface can evolve at runtime.

Can I connect my own model provider?

Yes. Provider connections are part of the product, including OAuth2-based setups for APIs that require it.

Is this only for Telegram bots?

No. Telegram is the current channel path in this repo, but the architecture separates channels from the rest of the agent runtime.

Why a sandbox at all?

Because useful agents eventually need to execute code or handle richer workloads, and that needs explicit operational boundaries.