Free deal audit: find out what your curated deals are leaving on the table. Request yours Free audit of your curated deals
Elcano / fleet

Put your agents to work on infrastructure you own.

fleet is an open platform for running AI agents. Talk work through in Chat, set up Patrols that check in on a schedule, run headless Background tasks, or drive it from your terminal. Any model, sandboxed, on a budget, and never holding your keys. You stay at the helm.

Themed per client

Everyone's piloting agents. Almost no one trusts them with real work.

The blocker was never whether an agent can draft a report or pull a number, it's whether you'd turn one loose on your systems, your data, and your budget unsupervised. Let an agent work on its own and one thing decides everything: whether you can trust it.

Three questions stand between trying agents and trusting them. fleet answers all three.

01

Can it do the job, every time?

An agent that works once but can't be repeated isn't something you can lean on. fleet makes a working setup repeatable and lets you watch it work.

  • Saves the setup that worked: prompt, tools, guardrails
  • Turns a working chat into a recurring Patrol, or runs it headless on a schedule
  • You watch each step live, not a black-box result
02

Should I trust it with this?

Trust isn't a leap of faith. It's known limits going in and a full record coming out, so a run can't surprise you on cost or hide what it did.

  • Hard cost and time ceilings that actually fire
  • A runaway agent costs one capped task, not an open invoice
  • Every action logged: what it did, what it cost
03

Am I comfortable giving up control?

You're not handing over control. You're defining it. You draw the lines on what an agent can reach and how far any mistake can spread.

  • You set what each agent can touch, create, and reach
  • A contained blast radius if something goes wrong
  • Keyless by design, with default-deny gates, scoped rules, and optional Auto-approve
The result: delegation you can watch, cap, and stop.
Four surfaces · one runtime

Work it out in chat. Put it on patrol.

Every surface talks to the same governed API, sandbox, budget ceilings, and audit trail: from an interactive first draft to recurring check-ins and headless background queues.

Talk it through
Chat

Work a problem interactively with your chosen persona and model. Watch tool calls stream live, branch threads to test alternatives, and share read-only links with your team.

Live tool traces Branching & share links
Runs without a chat
Background tasks

Run standalone scheduled and event-driven jobs headlessly, with priority queues, live SSE run streams, structured JSON output schemas, dead-letter replay, and network-sealed sandboxes.

Network-sealed JSON output schemas
Shell + HTTP API
Terminal chat

Drive the same personas, connectors, and trace logs straight from your shell with fleet chat, backed by an OpenAPI-specified HTTP interface with typed keys for CI and internal tools.

fleet chat OpenAPI + typed keys

What you get with fleet.

You run it, you own it

Your infrastructure, your data, your rules. Not someone else's cloud.

Any model, per task

Pick the best for each task and swap anytime.

No runaway bills

Hard cost and token limits per task, enforced as the agent works.

Your keys stay yours

Connects to the tools and data you already use without ever holding your credentials.

Standardize what works

Turn your team's best agent recipes into reusable, shareable workflows with a built-in eval harness so changes can't quietly break them.

Patrols that check in

Launch recurring schedules inside any chat via the Patrol Launchpad, with a live dashboard view, pre-approved self-addressed patrol emails, and an Auto-approve toggle in the Patrol bar.

Approvals that scale with trust

Default-deny gates pause sensitive actions until you allow once, scope a session rule by tool or argument pattern, or enable Auto-approve on a trusted chat or patrol.

Open and observable

MIT-licensed, with a full trace of every action and its cost. Proof, not promises.

Your fleet, your call

Run Victoria, the agent we built ourselves, or we'll help you stand up your own. The choice is yours.

We play nice with others.

fleet doesn't lock you into anyone, including us. Run models from every major lab, and switch the moment a better one ships. Connect the tools and agents you already use through MCP and agent connectors, from open-source servers to enterprise platforms. Your prompts, your guardrails, your data: standardized once, portable everywhere.

Victoria, the flagship agent we run our own business on, is proof of the idea, not the limit of it. Build your fleet from whatever agents you need.

Victoria OpenRouter

We didn't set out to build a platform.

We built Victoria, an AI agent for the hard part of programmatic ad ops: diagnosing what's working, spotting what isn't, and recommending the trades to make.  She worked so well that the platform we'd built to run her safely turned out to be a valuable thing. Sandboxed, cost-capped, and wired into live data.

So we're sharing it. It's not a demo, it's how we operate. Victoria is the flagship of a fleet you can build to fit.

Read the case study →

Proven in production, not in a pitch.

10,000+
operational decisions every month
measured from one internal ops team's usage: expert chat sessions, recurring patrols, and background runs
$0.21
for what used to be a $20 job
the same task after optimization: right-sized model, tuned prompt, tighter scope
Zero wait
for the newest models
fleet runs the latest models the day they ship: maximum intelligence, no platform lag
Security model

Sandboxed, brokered, gated, logged.

Isolated execution, brokered secrets, human approval gates, and a full audit trail, built in. Open source, on your own infrastructure.

rootless-podman
Rootless sandbox, no exceptions.

Every tool call runs in an ephemeral rootless-Podman container under host-enforced CPU/memory/PID caps. No fast path skips it. Need a harder wall? One config line upgrades every tool call to a dedicated KVM microVM (Kata or libkrun): escape then takes a hypervisor CVE, not a container break-out, and the runtime is verified fail-closed at boot.

mcp-broker
Credentials brokered host-side.

Secrets inject only for the call that needs them: never in the sandbox, the model's context, or the logs. The agent never holds your keys.

per-turn-ceilings
Hard ceilings, per turn.

Cost, token, iteration, and timeout limits, enforced. A runaway loop is a capped turn, not an open invoice.

fail-closed
Fail-closed by default.

Sensitive actions raise a default-deny allow/deny gate until a human approves once, scopes a session rule (narrowed by tool or argument pattern), or flips Auto-approve on for that chat or patrol. Headless background runs stay network-sealed and verified before they finish.

observer-events
Replayable audit trail.

Every tool call, result, token, and cost streamed live over SSE and persisted per turn. Judge the work from the trace.

loopback
Loopback by design.

Backends bind loopback-only behind your TLS, with optional IP allow/deny lists. Your data stays in your own Postgres.

Built by Elcano

Everything above is yours. The head start is us.

fleet is MIT-licensed and complete on its own. Your prompts, playbooks, and connectors live in a plain git repo you own, portable over open protocols. An Elcano engagement adds the parts that are yours alone: custom connectors, production workflows, and engineers who deploy forward.

fleet + an Elcano engagement
fleet: open source (MIT)
Chat, Patrols + scheduler, one binary
Sandboxed tool calls
MCP connector catalog
Any model, per task
Budgets, ceilings & audit
Chat · Patrols · TUI · API
+
elcano adds
Custom MCP connectors
Data integrations
Custom capabilities
Forward-deployed engineering
Production-ready workflows
Support & operations

See what your team could hand off.

Tell us what's on your plate and we'll show you where fleet fits.

Why teams choose fleet
  • Runs on infrastructure you own.
  • Hard cost caps on every task.
  • Never holds your keys.
  • Full trace of every action and cost.