AI agent platform

AI agents for the whole company. Connected to what you already use, with proof of how they work.

Bastino is not just the ERP copilot. It is a platform to build, connect, orchestrate and govern agents: it talks to your systems through MCP, 28 connectors, any API with OpenAPI and webhooks, and another system can assign it work through its API. Every step is recorded in a trace.

For IT, operations and product teams who need agents in production, not a demo.

  • Works without the business modules
  • Errors, context, traces and MCP, measured
  • Never more than the person using it
admin/bastino/traces
A real trace. The model asks for a record without its id and gets "invalid input" with what it has to correct. Fictitious data.
In one minute

The four questions you ask an agent platform

An analyst asked them about Bastino. These are the short answers; each one links to its section, with screenshots and figures.

The ERP is not required

An agent platform, with or without the business modules

Bastino does not depend on any business module. Its tools are an open catalog: what is not active does not appear. For an agent platform, these modules are enough, and each one is activated separately.

ModuleWhat forRequired?
BastinoThe agent engine: loop, tools, cards, inbox, governance, MCP client and server.Yes
AI agentsWhere each agent lives: name, instructions, provider and model.Yes
Agent StudioDesign, test, publish and measure agents; custom tools; agent API; agents as files.Yes
Fisher ConnectConnections to third-party systems and the generic REST API.To orchestrate outside
AutomationsFlows with triggers and the "agent with tools" step.Recommended
WebhooksReceive events from outside and send the platform's events.Recommended
APIAPI keys for the agent API and the rest of the REST API.For the agent API
Virtual companyA team of agents with an org chart, assignments and escalation to a person.Optional
Agent storeReady-made roles and procedures by industry, in signed packages.Optional

Honestly: the Fisher Platform core (staff, customers, settings, email) is always there, even if you do not use it. There is an "Agent platform only" plan with exactly this list.

What it orchestrates that is not Fisher Platform

External MCP servers

Any MCP server over HTTP, from both eras of the specification, with OAuth 2.1 if required: with the installation's connection or with each person's account. The chat, tasks, the Virtual company, channels and Studio agents use them.

28 Fisher Connect connectors

Microsoft 365, Google Workspace, Salesforce, SAP Ariba, SAP SuccessFactors, Workday, Jira, ServiceNow, HubSpot, Stripe, Slack and more, plus a generic REST API. The agent reads directly and proposes writes with a card.

Any API, without code

Import an OpenAPI 3.x document in JSON or YAML, or define the operation by hand, and it becomes a tool for your agents. A GET reads; everything else writes with a card. They are created switched off.

Signed webhooks

An outside event triggers an agent or a flow; the result of a job goes out as an event. HMAC signature, queue and network filter.

Agent API

Another system assigns work to an agent and waits for the result, follows it live or receives it by webhook. See the example.

Flows with an agent inside

In Automations, a step is done by an agent with its tools, with round and token limits. Whatever it proposes to change goes to the inbox.

Connectors

Each connection says what Bastino can do with it

  • Three levels per connection: not used, read only or read and propose writes. By default, not used.
  • Always with the permissions of whoever is asking: a personal connection is used only by its owner.
  • Forbidden actions that cannot be reduced: creating users in a directory, changing passwords, invoking AWS functions…
  • Quota per person and hour, and the third party's response reaches the model trimmed and flagged as untrusted data.
admin/connect/connection
A connection page. "Bastino can use this connection": read and propose writes, with a card.
Custom tools

From an OpenAPI document to an agent tool, without a line of code

  • Always on top of a connection: the server and the encrypted credential belong to the connection, not to the document.
  • OpenAPI in JSON or YAML, with a preview before importing: which operations come in, which read and which write.
  • Business headers (allowlisted: never authentication or cookies), JSON, form or multipart bodies with chat attachments, text responses, files saved as attachments if enabled, and pagination.
  • External references in the document are rejected. Downgrading a write to a read: administrators only, with a reason.
  • Its own permission, "Custom tools", which is not granted to any role at first.
admin/agent_studio/tools
Custom tools on a carrier's API.
Import OpenAPI: preview before creating anything.
Several agents

A team of agents, not just a chat

  • Virtual company: a Director assigns work to roles, reviews what is delivered (accept, redo or escalate) and leaves the daily summary for a responsible person.
  • Each role is an agent with its mission, its indicators and a real responsible person, and it works with that person's permissions.
  • Shadow mode, earned autonomy and event subscriptions.
  • Agent store: ready-made roles by industry, in signed packages, installed in shadow mode.
admin/virtual_company
Virtual company. Org chart of agents and daily reports.

Model per agent

Claude, OpenAI, Azure OpenAI, Gemini or a compatible self-hosted model. Each agent with its own.

Channels

Panel, portals, chat embedded in your website, WhatsApp, Telegram, real-time voice and calls.

Agent Studio

Instructions, knowledge with citations, guided topics, test pane, batch evaluation with a judge and versions. See it.

Agents as files

Agents and flows are exported and imported as versioned JSON, with a preview and without secrets. An agent can carry the text of its documents.

Agent API

Your system assigns work to an agent

A third-party ERP, a portal or your own flow sends the job. It can carry on with its work, wait for the result in the same call or follow it live. The agent works in the background, as the person who owns the key, with that person's permissions, budget and quota at that moment.

  • 202 with the job number; the status can be polled or arrives by webhook (agent_studio.run_finished and agent_studio.run_settled).
  • Wait for the result: with Prefer: wait=N the call returns 200 with the finished job; if it does not finish in time, the usual 202. It only waits if a queue worker is alive.
  • Live events (SSE) at GET …/runs/{run}/events: status, partial text, tools (without their input or output), proposals, errors and end. Resumable with Last-Event-ID.
  • Waiting and events start switched off and have a cap on open connections: 2 per key and 4 per installation, by default.
  • Idempotency-Key: the same job sent twice returns the same response. context reaches the model as untrusted data, never as an instruction.
  • Whatever the agent wants to write stays in the inbox (awaiting) until a person decides. Off by default, and opened agent by agent. Described in /api/openapi.json.
# Assign work to agent 12 and wait up to 20 s
curl -X POST https://your-instance/api/bastino/agents/12/runs \
-H "authtoken: $API_KEY" \
-H "Idempotency-Key: order-PV-18842" \
-H "Prefer: wait=20" \
-H "Content-Type: application/json" \
-d '{"message": "Review order PV-18842",
"context": "3 parts arrived damaged"}'
# 200 OK if it finished in time (Preference-Applied: wait=20)
{"run_id": 381, "status": "awaiting", "proposals": [ … ]}
# 202 Accepted if not: {"run_id": 381, "status": "queued", …}
# Live: GET /api/bastino/agents/12/runs/381/events
event: tool · event: proposal · event: end

Statuses: queued, running, done, awaiting (something to decide) and error. Errors: 404, 413, 422, 429 (quota or no free connections), and 503 when it is off.

Queue worker

Jobs that start within seconds, without depending on cron

  • Optional: php spark bastino:worker as a service (systemd or supervisor). Without it, everything keeps running on the scheduled task every minute.
  • It handles the agent API, Bastino tasks, webhooks, queued automations and the OpenTelemetry export.
  • It uses the same atomic reservations as cron: both can coexist without doing anything twice.
  • Each batch runs in a child process, with the permissions of that moment and with time and memory limits.
  • Bastino → Workers screen: who is alive, what it handles, what is queued, "Pause" and "Restart". Its own permission, not granted to anyone at first.
admin/bastino/workers
Bastino → Workers, with two workers running.

Measured agent API latency

CaseQueued → startsQueued → finished
Without a worker (cron every minute)0–60 sthe same + the turn
With a worker (5 jobs in a row)1.62–1.81 s2.1–3.3 s
Prefer: wait=20 with a worker—200 in 3.0 s
Prefer: wait=10 without a worker—202 in 0.5 s (does not wait)

Measured on 2026-11-21 on the same development Intel MacBook Pro, with PHP 8.3, MySQL 8.4 and a scripted model. Almost all of the second and a half is starting the child process: in exchange, each job runs isolated and with the permissions of that moment.

Errors in tool chains

When something fails halfway, the agent knows what happened and does not make it worse

An agent chains tools. What matters is what it does when one fails: correct, retry, explain or stop. This is what Bastino does in version 3.82.

Errors with a class

Invalid input, no permission, transient failure, timeout, business rejection or internal failure. The model gets the class, whether it is retryable and a message without secrets, paths or SQL.

Validation before running

The input is checked against the tool's schema (required fields, types, allowed values) before touching anything, writes included. The model is told what to correct.

Loops cut off

The same tool with the same input failing 3 times in a row cuts the turn off, and the chat says which tool is failing.

AI provider down

Retries with exponential backoff that honor Retry-After, an optional fallback provider and a circuit breaker: 5 failures in a row and it is skipped for 60 s. Every attempt is recorded in the ledger with its cost.

Time limits

30 s per tool by default. What goes over HTTP is really cut off; the rest is measured and flagged. In the queue worker, each batch has its own limit and is cut off.

Writes are not repeated

They are proposed, confirmed and applied atomically, with per-action undo. A write caught halfway by a crash is marked "unknown whether it was applied" and is never repeated on its own.

Validation

The model gets it wrong; the chain does not break

In this trace, the model asks for a customer record without its id. The tool never runs: the model gets "invalid input", what is missing and that it is not retryable as is. In the next round it asks for the record correctly and finishes the answer. Everything stays in the cascade, with its cost.

admin/bastino/traces
Validation error corrected in the next round.
Dead-letter queue

What did not go through, in plain sight and with "Retry"

  • A task stuck for more than 30 minutes resumes once where it stopped; a stuck event goes back to the queue once.
  • A failing event is retried with increasing waits, up to 3 times.
  • If it already left something proposed, it is not retried on its own: it would duplicate cards.
  • Whatever runs out of attempts goes to the dead-letter queue with its last error, "Retry" and "Discard". Bastino can do the same with a card.
admin/bastino/tasks
Dead-letter queue in My tasks.
Fallback

The main provider fails; the fallback takes over

In this trace, the first provider returns a server error twice in a row (attempt and retry). Bastino switches to the fallback provider, which runs the search. In the next round the main provider responds again and gives the answer. The trace says who answered in each round.

admin/bastino/traces
Retry and fallback in the same trace.
Context recovery

Long conversations, interrupted tasks and what must be remembered

A useful agent does not forget halfway through a long conversation or repeat work when something crashes.

Summaries that break nothing

Past 40 messages or 60,000 tokens, the older part is summarized and the summary travels with the last 12 messages. It always cuts at the start of a turn: no tool call and result pair is split. The chat shows "Conversation summarized".

Tasks that resume

An interrupted task continues at the round where it stopped, without sending the job again. A read without a result is run; a write already applied is not applied again.

Fact memory

"Remember that…" is saved with a card, never silently, for the person or for the company, with an optional expiry. Only the relevant facts travel with each question, by keywords or by meaning. Nothing that looks like a secret.

Prompt cache

The prompt is split into a stable part and a variable part so the provider can cache it. The trace shows the tokens read from cache and the savings.

Knowledge with citations

Documents, websites and SharePoint, OneDrive and Google Drive folders, with keyword and semantic search. Citations are checked on the server. Semantic search over 10,000 chunks in 111 ms; optional external Qdrant engine.

Context between agents

In the Virtual company, the Director passes context to each role through the database (the assignment, its history and what was delivered), not in the prompt.

Measured semantic search (1536-dimension vectors)

ChunksBeforeVersion 3.82 (MySQL)Recall (top 10)
10.0004,654 ms111 ms10 of 10
100.000out of memory with 2 GB≈ 2 s8 of 10

A first cut by signs computed in MySQL and exact cosine only on the best candidates. For more volume or better recall, raise the cut or use the external engine (Qdrant). Measured on the development machine described further down.

Observability

What each agent did, how long it took and how much it cost

Each turn is a trace in W3C format: the question, each model call, each tool, each applied action and the business record that changed.

admin/bastino/traces
Traces. Filters by person, specialist, status, origin, errors, slowness and date; CSV export. Fictitious data.
Reliability

A dashboard to know whether the system is failing or the model is

  • Errors by provider and by tool, retries, fallback switches, circuit breaker skips, p50 and p95, cache savings and dead-letter queue.
  • It separates operational errors (internal failure, timeout, transient failure, loop) from the model getting it wrong (invalid input, no permission).
  • Internal alerts by error rate, p95 latency and dead-letter queue, and the bastino.alert event for your webhooks.
  • Dedicated MCP server and client spans, also in OpenTelemetry, with traceparent sent to external systems.
  • From the changed business record you can reach the action, the tool and the turn.
admin/bastino/usage/reliability
Reliability, with demo data.
OpenTelemetry

Traces, in your own collector

  • OTLP/HTTP with JSON to …/v1/traces, with the GenAI conventions: invoke_agent, chat and execute_tool, tokens with cache and error type.
  • Off by default. It is sent only from a scheduled task, never during anyone's turn, through the network filter and over https only.
  • By default, without content. With content: tool arguments and results masked and trimmed; never the prompt or what the person writes.
  • Encrypted authentication header, never shown again and erased if the server changes.

Also

The usual governance
  • Budgets per person, role, gate, specialist and installation.
  • Every model call measured in tokens and money, by provider and model.
  • Audit with configurable retention and CSV export.
  • Batch evaluation of agents with rules and a model as judge.
  • A JSON trace per turn, to attach to an incident.
MCP at scale

MCP in both directions, ready for many servers and many tools

Checked against the current MCP specification (2026-07-28). Bastino is a client of third-party MCP servers and an MCP server for Claude, ChatGPT, Copilot or any other client.

Stateless server

No sessions and no open stream: the connection is the token. Quotas, slots and metrics live in the database, so any node behind a load balancer serves any request.

Paginated lists

Opaque signed cursor bound to the connection, consistent pages, ttlMs, cacheScope: private and a list fingerprint with ETag.

Quotas and concurrency

Per connection, per OAuth client (300/min) and global (1,200/min), plus 4 concurrent requests per connection. 429 with Retry-After. Usage per client with p50 and p95.

Deferred tools

A server with more than 15 tools does not send its schemas to the model; the agent finds them with mcp_buscar when needed. At most 40 external schemas per round.

Robust client

One client per turn, connection and call timeouts, retries for reads only and a per-server circuit breaker with "Resume". Outbound OAuth 2.1 with PKCE.

Across the whole system

External servers are no longer just for the chat: tasks, the Virtual company, channels and Studio agents use them, with the person's permissions.

Catalog cache

The server caches each person's tool catalog and invalidates it with a fingerprint of their permissions, roles, modules and settings. A tools/list costs as much as starting the application.

List-changed notice

A subscriptions/listen stream with toolsListChanged, as the current specification requires. Off by default, with a cap on concurrent streams, a maximum duration and a heartbeat.

MCP spans in the traces

Each request to Bastino's server and each call to an external server is a span in "Traces" and in OpenTelemetry. traceparent is sent outward; one arriving from outside is stored as a link, never as a parent.

admin/bastino/mcp
MCP connections. Health per server: the TMS keeps failing and is paused with "Resume". Fictitious servers.
My connections

Each person, with their own account on the external system

  • Per server, the administrator chooses: the installation's connection (default) or "each person connects their own account" via OAuth 2.1.
  • Bastino uses the account of whoever is working: in the chat, in their tasks and in the Virtual company. Without an account, it does not offer those tools and says where to connect it.
  • Encrypted tokens, never shown again, erased if the server changes, if the person leaves or if they disconnect.
  • One person's expired account does not pause the server for everyone else.
  • If an external system asks the user for data, Bastino says so clearly instead of failing, without showing the third party's message or link.
admin/bastino/connections/accounts
My connections. Personal accounts on fictitious systems.

Measured figures

On a development Intel MacBook Pro (12 threads), Apache with PHP-FPM 8.3 and 5 processes, local MySQL 8.4, about 90 active modules and a scripted model. Reproducible script with a fake 500-tool server and ab. Tables 1 and 4: 2026-11-20. Tables 2 and 3: 2026-11-21, with version 3.82 and, in parentheses, 3.81 on the same day. It is a modest machine on purpose: the figures show where the ceiling is.

1. What travels to the model per round

CaseToolsExternalSchemasTokens
No MCP servers97066.3 KB~16.970
+ 500-tool server, deferred (default)98166.9 KB~17.120
+ 500-tool server, not deferred597500268.1 KB~68.620

With deferred tools, a 500-tool server costs about 150 extra tokens per round instead of about 51,650.

2. Paginated lists from Bastino's MCP server (≈ 134 tools)

Page sizeRequestsTotal timeSlowest
All at once, first time (no cache)1719 ms (2,090 ms)719 ms
25 (from the cache)63,230 ms (4,576 ms)690 ms
100 (default, from the cache)21,186 ms (2,545 ms)681 ms

Most of the earlier time went into fetching each tool's label one by one; now it comes from the definition already built, and the catalog cache removes the rest. A request now costs as much as starting the application (≈ 0.5 s on this machine).

3. Concurrency against Bastino's server (one token, 5 PHP-FPM processes)

CaseReq./s429p50p95
tools/list one at a time1,9 (0,5)0529 ms (2,052 ms)543 ms
tools/list, 20 concurrent, no quotas6,8 (1,6)02,855 ms (12,711 ms)3,421 ms (13,943 ms)
tools/call one at a time1,50662 ms734 ms
tools/call, 20 concurrent, no quotas5,603,439 ms4,084 ms
tools/call, 20 concurrent, global quota 120/min5,61803,404 ms4,492 ms
tools/call, 20 concurrent, 4 per connection (default)4,424,266 ms5,540 ms

The ceiling is PHP-FPM: 5 processes × ≈ 0.6 s per request ≈ 7–8 requests per second. With 20 concurrent, the rest waits in the queue and latency goes up, without errors. The global quota cuts exactly what goes over 120 in the minute (300 − 120 = 180). For more, more processes or more nodes.

4. External server down, silent or slow (read, 2 retries, circuit breaker 5 → 120 s)

CaseCalls 1 to 5Calls 6 and 7 (paused)
Down (connection refused)1.4–1.6 s0 ms
No response1.8–1.9 s0–1 ms
Slow (takes 5 s; 2 s timeout)2.0 s0 ms

Without a circuit breaker, every question touching that server would wait just as long. With it, by the sixth call there is no more waiting and its tools leave the catalog until the pause ends or someone presses "Resume".

Governance and security

An agent with access to your systems has to be predictable

Bastino does not depend on the model "behaving". The server enforces the rules.

  • The permissions of whoever is talking. The agent is the person, not one permission more. A specialist gets the intersection of its tools and the person's.
  • Confirmation card. Reading is done; changing is proposed with the before and after. On an external system, the card shows the system, the connection, the action and each piece of data.
  • Atomic. A confirmation is applied only once, even if pressed twice.
  • Per-action undo. It refuses if the record changed afterwards. What cannot be undone is stated when deciding.
  • Actions that do not exist. Installing modules, granting itself permissions, lowering security or deleting backups are out of its reach, and no setting changes that.
  • Budgets and quotas per person, role, gate, specialist and installation.
  • Audit of every question and every tool.
  • Third-party data as untrusted data: responses from MCP, connectors, webhooks and the API context are never instructions.
  • Everything that opens doors starts switched off: fallback, OpenTelemetry, connectors for Bastino, agent API, waiting for the result, live events and the MCP list-changed notice. The Traces, Custom tools and Queue workers permissions are not granted to anyone at first.
admin
Write to an external system. Bastino proposes creating the Jira issue and waits for the click.
Comparison

What is expected of an agent platform, and where to see it here

Today it gets compared with three families: agent studios (such as Copilot Studio), developer orchestrators (such as LangGraph) and workflow automation (such as n8n). We do not speak for them. This table lists what is usually asked for and how Bastino handles it.

What is expectedHow Bastino handles itWhere to see it
Design and test agents without codeAgent Studio: instructions, knowledge with citations, guided topics, test pane, batch evaluation with a judge, draft and versions.Studio
Several agents working togetherVirtual company (Director, roles, review and escalation) and the "agent" step in Automations.Several agents
Tools from any systemMCP client, 28 connectors, custom tools from OpenAPI (JSON or YAML) and a generic REST API.Orchestrates outside
Flows with triggersAutomations, scheduled and event-driven tasks, inbound and outbound webhooks.Workflows
Background executionOptional queue worker: jobs start in under two seconds; without it, the scheduled task every minute.Worker
Identity in external systemsThe installation's connection or each person's OAuth account on MCP servers.My connections
Error handling and retriesErrors with a class, schema validation, loop cutoff, retries, fallback, circuit breaker and dead-letter queue.Errors
State and memoryConversation summaries, tasks that resume, fact memory and prompt cache.Context
Traces and metricsPer-turn W3C traces with MCP spans, reliability dashboard, alerts and OpenTelemetry export.Observability
A person in the loopA card for every write, a proposals inbox, approval from messaging apps and undo.Governance
API to integrate itAgent API with idempotency, waiting for the result, live events and webhooks, and an MCP server with OAuth 2.1.API
PortabilityAgents and flows as versioned JSON files, optionally with the text of their documents; signed packages in the Agent store.Agents as files
Choice of modelFive providers and self-hosted models, with provider and model per agent.Suppliers
Enterprise securityThe person's permissions, critical actions that do not exist, third-party data as untrusted, budgets and audit.Security
Frequently asked questions

What a technical buyer asks

Is Bastino just the ERP copilot?

No. It is also an agent platform: it can be activated without the business modules and it orchestrates systems that are not part of Fisher Platform through MCP, 28 connectors, any API with OpenAPI, webhooks and its own agent API.

What happens if a tool fails in the middle of a chain?

The error goes back to the model with its class (invalid input, no permission, transient failure, timeout, business rejection or internal failure) and a message without secrets. The input is validated against the schema before running. If the same call fails three times in a row, the turn is cut off. Writes are never repeated on their own.

And if the AI provider goes down or is overloaded?

Bastino retries with exponential backoff and honors Retry-After. If configured, it switches to a fallback provider. A provider that fails five times in a row is skipped for a while (circuit breaker). Every attempt is recorded in the trace with its cost.

How does it recover context in a long conversation or in a task that was interrupted?

Long conversations are summarized automatically without splitting tool call and result pairs. An interrupted task resumes at the round where it stopped, without applying again what was already applied. There is also a memory of preferences and of facts confirmed by the person, and knowledge with verified citations.

How do I see what an agent did and how much it cost?

Each turn is a W3C trace with its model calls, its tools, its MCP calls, its actions and the business record it changed, with duration, tokens, cache and cost. You see it on the Traces screen, export it as JSON or CSV and, if you turn it on, send it to your collector over OpenTelemetry (OTLP/HTTP) with the GenAI conventions.

Does Bastino's MCP scale?

As a server, it keeps no state: any node behind a load balancer serves any request. It serves lists in pages, caches each person's catalog and has quotas per connection, per client and global. In the published measurements for version 3.82, a tools/list went from 2,052 ms to 529 ms and, with 20 concurrent requests, from 1.6 to 6.8 requests per second. As a client, it defers the tools of large servers: one with 500 tools adds about 150 tokens per round instead of about 51,650.

Can another system assign work to an agent?

Yes, with the agent API: POST /api/bastino/agents/{id}/runs with a person's API key. The job runs in the background with that person's permissions. The result can be polled, arrive by webhook, be awaited in the same call (Prefer: wait=N) or be followed live through SSE events. It supports Idempotency-Key. It is off by default and is opened agent by agent; waiting and events are also off by default.

Do I need a separate process on the server?

No. Out of the box, background work is run by the scheduled task every minute. If the server allows it (systemd or supervisor), the optional queue worker php spark bastino:worker handles it within seconds: in the published measurements, a job sent through the API starts between 1.6 and 1.8 s after being queued.

Does Bastino use my own account in external systems?

If the administrator sets it up that way, yes: each person connects their own account for an MCP server in "My connections" and Bastino uses it in the chat, in their tasks and in the Virtual company. Without an account, it does not offer that system's tools and says where to connect it. By default, the installation's connection is used.

Can an agent write to Salesforce, Jira or my API without anyone seeing it?

No. Reads are direct, but every write to an external system is proposed on a card with the system, the action and each piece of data, and a person applies it. In addition, each connection decides whether Bastino does not use it, only reads, or reads and proposes writes.

Which AI models does it support?

Claude (Anthropic), OpenAI, Azure OpenAI, Google Gemini and OpenAI-compatible servers for your own models, such as Ollama. Each agent can have its own provider and model, with its key.

Are there service accounts for agents?

No, on purpose. An agent always acts as a person or with a person's API key, and can never do more than that person. For an external system, you create a technical user with exactly the right role and its key.

Limits

What it does not do, stated clearly

An agent platform is also chosen by its limits. These are the ones in version 3.82.

What it doesn't do

Version 3.82
  • Without a queue worker, it depends on cron. Where a long-running process is not possible (shared cPanel hosting), a job sent through the API can take up to a minute to start, waiting for the result does not wait and events arrive when cron picks up the job.
  • Streams cost one PHP process each. Waiting for the result, live events and the MCP list-changed notice hold a web server process while they last: that is why they start switched off and with low caps. Events are read from the database every 400 ms; it is not a message bus.
  • No SSE progress on tools/call. The MCP server answers calls in JSON, which is compliant: no tool emits progress.
  • No elicitation. If an external system asks the user for data, Bastino explains it but does not ask them for it (in a task there is nobody there).
  • MCP over HTTP only. No stdio: it would mean launching processes from the web server. Disconnecting an OAuth account erases it here; on the external authorization server it expires on its own.
  • The ceiling is PHP-FPM. Each MCP request starts the application: for more requests per second, more processes or more nodes.
  • There are no service accounts. An agent always acts with the permissions of a person or of a person's API key.
  • It does not write outside on its own. Connectors, custom tools and API jobs propose; a person confirms.
  • It does not stop a PHP tool halfway in the chat or in cron: the time limit cuts off what goes over HTTP and the rest is measured. With the queue worker, each batch has a limit and is really cut off.
  • An interrupted task resumes once. If it crashes again, it is marked as failed and goes to the queue.
  • Semantic search without an external engine: 8 of 10 with 100,000 chunks. For better recall or more volume, raise the cut or use Qdrant. Keyword search goes through the chunks in PHP.
  • Custom tools: never cookies or authentication headers (they belong to the connection); a response file only as an attachment and only if enabled; pagination by cursor or by page, not by the Link header. YAML: the subset OpenAPI uses (no anchors or aliases).
  • Exporting an agent carries the text of its documents, not the original file. Pages, sites and SharePoint or Drive folders travel as references and are connected again.
  • A traceparent arriving from outside is stored as a link, not as a parent, on purpose: a third party's id does not decide which trace data is added to. The OpenTelemetry GenAI conventions are still in development.
  • The core is always there. An "agents only" installation has staff, customers and settings, even if it does not use them.

What is not a limit: JSON-RPC batches, the GET stream and MCP sessions. The current specification (2026-07-28) removed them; a compliant server answers one message per request, and that is what Bastino does.

And one more: no model is infallible. That is why critical actions do not exist, protected ones are rejected by the server and every write goes through a person. The model can be wrong; your systems do not change without you.

See it with your systems

We show you an agent connected to your tools through MCP, a connector or your OpenAPI, with its traces, its errors and its reliability dashboard.

About the screenshots, the data and the sources

The screenshots are from versions 3.81 and 3.82 (Workers and My connections) in a demo environment with a fictitious company and people. The turns in the traces were produced by Bastino's real engine with a simulated AI provider (no real provider was called); the MCP servers, the personal accounts, the Jira connection and the carrier's API are fictitious, and the jobs on the Workers screen were handled by a real queue worker. The figures come from the scripts published in the product's technical documentation, measured on the machine described on the dates given. Trademarks belong to their owners; the names of other products only indicate the category it is usually compared with.

View plans