What We Shipped in October 2026

September brought connic voice, the Playground, and browser tools. In October, agents got a frontend and a place to keep their files. connic apps hosts the web apps that people use to work with agents, and connic files stores what agents produce from one run to the next. Connectors can now be declared in code next to the agents they start. Run drains forward every finished run and its trace to monitoring tools. The browser tools now read pages, run scripts, record network traffic, and sign in with passkeys, and the managed catalog added models such as GPT-6, Claude 5.5, and Gemini 4 Argon.

Frontends for Agents with connic Apps

connic apps hosts the screens people use with agents: a chat on a website, an inbox for approvals, a customer portal. Each app is a YAML file in apps/ plus a folder with its sources. Every deploy builds it together with the agents, every environment serves it on its own connic.app address, and a rollback brings back the older frontend with the older agents. Frameworks that build static files work, such as Vite with React or Vue, Angular, Astro, SvelteKit, and Nuxt.

name: Support portal
build:
  command: npm run build
  output: dist
auth:
  mode: connic
connectors:
  - portal-chat
access:
  database:
    tickets:
      read: doc.author_id == user.id
      insert: true
      set:
        author_id: user.id

Apps call agents through sync webhook or WebSocket connectors marked with apps_only: true, so the app's code contains no API key. Runs started from an app carry the visitor's ID, email, name, and groups in the run context. An app can also be served on a custom domain. Apps are part of the pro and enterprise plans.

The connic apps announcement walks through example apps, and the apps documentation covers every setting.

Persistent Storage with connic Files

connic files gives every environment a folder tree where agents keep files between runs. An agent saves a report or a browser download, and a later run, or another agent, picks it up again. Five file tools cover the tree: file_list, file_read, file_write, file_update, and file_delete. Custom tools import the same functions from connic.tools. File contents are encrypted at rest with a separate key for each environment.

Without further configuration, an agent can use the whole tree. A files block limits it to certain folders, blocks writes or deletes, or keeps it to the files of its current session:

session:
  key: input.customer_id

files:
  session_only: true          # only files written in this customer's session
  prevent_delete: true
  folders:
    cases: {}
    templates:
      session_only: false     # shared by every session
      prevent_write: true

The connic files announcement includes an invoice example, and the files documentation lists limits and billing.

Connectors Defined in Code

Connectors can now be declared in connectors/<key>.yaml, next to the agents they start. When a deployment is activated, connic creates, updates, or retires the connectors of that environment to match the files, and a rollback restores the connectors of the older deployment. Every connector type except Slack can be declared this way.

type: kafka
mode: inbound
name: Order events                # optional, defaults to the file name
connection: orders-kafka-staging  # saved Connection, by name or ID; it holds the bridge too
config:                           # connector settings, as in the REST API and connic MCP
  topic: ${ORDER_EVENTS_TOPIC}
agents:
  - order-processor
  - name: audit-logger
    files_required: true
environments:                     # omit to deploy to every environment
  Staging: {}
  Prod:
    connection: orders-kafka-prod   # another Connection, with the production bridge
    config:
      group_id: connic-orders-prod

environments overrides settings per environment, and ${NAME} reads a variable of the target environment when the deploy starts, so secrets stay out of the files. The deploy log lists every connector change, and before a rollback, the activate dialog shows which connectors it will create, update, bring back, or retire. A connector the code no longer declares is paused and keeps its URL, secrets, and run history. connic lint checks connector files before they are uploaded.

The connectors in code documentation covers overrides, variables, and failed connector changes. Deprecated API fields keep working until April 30, 2027, as the REST API reference explains.

Run Drains and OpenTelemetry Export

Run drains forward agent runs to the monitoring tools a team already uses. A drain sends one event for every finished run with its input, output, and context, every span of the run's trace, and a health snapshot of each environment once a minute. Nothing is truncated.

Run drains are set up on the Agent Runs page under More actions → Run Drains. Like log and audit drains, they are part of the enterprise plan.

The drains documentation describes the event formats and every channel.

Browser Tools That Read, Script, and Sign In

Five new tools joined the browser tools from September. web_browser_read returns the rendered page as Markdown, including content behind a login. web_browser_eval runs JavaScript in the page, either inline or from a script stored in connic files. web_browser_console returns console messages and page errors, web_browser_network records requests and can save them as a HAR file, and web_browser_pdf saves the page as a PDF. web_browser_act can now hover, check boxes, scroll an element into view, and wait for text, a URL, a selector, or network idle. Screenshots can capture the full page.

from connic.tools import web_browser_eval

await web_browser_eval(
    "[...document.querySelectorAll('h2')].map(h => h.textContent.trim())"
)

await web_browser_eval(
    script_path="scripts/collect-rows.js", save_to="exports/rows.json"
)

Agents can also sign in on sites that accept passkeys. Passkeys are managed per environment in the project settings: a new passkey is stored the first time the agent's browser registers one on its domain, or an existing passkey is imported. The agent lists the passkeys it may use:

tools:
  - web_browser_*

browser:
  passkeys:
    - supplier-portal

The web tools reference documents every browser tool, and our browser automation guide now covers location, time zone, and opening the browser from middleware.

MCP Servers per End User

Some MCP servers act for one person and show each user only their own data. An agent can now call such a server with each end user's own account. The user signs in once through a link, connic stores their access, and every later run for that user uses it. A context value that middleware sets, such as context.user_id, identifies the user. Runs for users who have not signed in leave the server out.

mcp_servers:
  - name: crm
    url: https://crm.example.com/mcp
    oauth:
      app: crm                # sign-in app, set up per environment in Project Settings
      user: context.user_id   # set by middleware for every run
      connect_tool: true      # adds connect_crm for conversational agents

A chat agent can hand out the sign-in link itself through the generated connect_crm tool. Other systems create links through the REST API or connic MCP.

MCP servers also accept condition, which attaches a server only when an expression over context or input is true, and optional: true, which skips a server that fails to connect instead of failing the run. Tool hooks now apply to MCP tools: before can rewrite arguments or stop the call, and after can trim or replace the result before the model sees it.

The MCP documentation covers per-user sign-in and conditional servers. The tool hooks reference shows hooks for MCP tools.

Call Transfers and Live Chat Progress

Voice agents can now hand a call to a person. A tool raises TransferCall with a number in E.164 format, the speech that is already playing finishes, and the caller is connected. The allowed numbers are listed as Transfer numbers on the Twilio Voice or Telnyx Voice connector. A Fallback number takes the call when the run fails or the call cannot continue.

from connic import TransferCall


def transfer_to_sales(context: dict) -> str:
    """Transfer the caller to the sales team."""
    raise TransferCall("+4930123456789")

voice_config.keypad maps phone keys to tools. A key press runs its tool at once without a model turn, even during the greeting. Callers hear a ringing tone until the agent is ready to speak, and the run input carries the call details, such as the caller's number and the number they dialed.

Chats over the WebSocket connector can show what the agent is doing while it works. With progress_events, the connector also sends an event when a model call starts, when each tool call starts and ends (with the tool name only), and when an approval is waiting or resolved. With session.key, the conversation history survives reconnects. Text streamed before an approval pause is kept when the run resumes.

The voice documentation covers transfers and keypad input. Our streaming chat tutorial builds a chat with progress events step by step.

Rate Limits and Sender Checks for Connectors

Webhook, WebSocket, and MCP connectors can now limit requests per minute: in total, per client IP, and per value of a payload field, such as a customer ID. A request over a limit is rejected before a run starts and uses no Project credit.

type: webhook
mode: inbound              # or sync
config:
  require_auth: true
  rate_limit:
    per_ip: 60
agents:
  - order-processor

Webhook runs now pass the original request to middleware as context["request"]: method, headers, query, raw body, and the time connic received it. Middleware can check a sender's signature, such as GitHub's X-Hub-Signature-256, before the agent runs. Run details show the body and credential headers as [REDACTED].

The webhook documentation includes signature checks for GitHub and Microsoft Teams, and the cron documentation explains daylight saving time.

SharePoint, Zendesk, and Database Search

Retrieval has two new synced sources. The SharePoint and OneDrive source syncs document libraries through the company's own Entra ID app registration, limited to selected sites, libraries, folders, or files changed since a date. After the first sync, only changed files are synced again. The Zendesk Help Center source syncs published articles, with each article's translations as separate entries.

Retrieval also reads Word, Excel, PowerPoint, OpenDocument, RTF, HTML, and email files (EML and MSG). File uploads can be up to 100 MiB with up to 25 million characters of text, and text uploads up to 10 million characters. A file upload through the REST API can carry custom metadata.

from connic.tools import db_find

# Pickup points within 25 km, nearest first
# (each document has "location": {"lat": 48.15, "lng": 11.58})
result = await db_find("pickup_points", filter={
    "location": {"$near": {"lat": 48.137, "lng": 11.575, "maxDistance": 25000}},
})
nearest = result["documents"][0]
nearest["_distance"]          # meters from the point

The Retrieval documentation covers the SharePoint setup, and the database documentation covers imports and searchable fields.

Token Costs per Customer and in One Currency

Token costs can now be grouped by any run context value. With a customer_id in the run context, the By Context tab on the Token Usage page shows what each customer costs per day. Dashboard widgets and the budget API group costs the same way. Our guide to tracking token costs by customer shows the setup.

Projects with model prices in both euros and dollars can show every token cost in one currency. Cost Display under Project Settings → Token Pricing converts amounts with the European Central Bank's daily reference rates and marks them with ≈.

The usage documentation explains how token costs are calculated.

New Managed Models

The managed catalog added 20 models in October. Each one has a model ID such as connic/claude-sonnet-5.5 and bills from Project credit, without a provider account.

Managed models such as Claude 5 and 5.5, Gemini 4 Argon, the Gemini Flash models, and GPT-5.6 now read attached PDFs directly. When a model rejects an attached file type, the run moves straight to the fallback model, and the deploy log warns when a fallback model accepts fewer file types than the primary one.

The managed model catalog lists current prices and the file types each model accepts. Our articles on Mistral Large 4 and Kolibri 1 cover two of the new models in depth.

More Improvements

• •Runs finish on their deployment: A new deployment no longer interrupts running agents. Each run finishes on the deployment it started on, and queued runs start on the new one. If a new deployment fails after its deploy step, the previous deployment stays active. Deployment documentation
• •Setup with a coding agent: New projects start with a wizard that walks through connecting a coding agent such as Claude Code, Codex, or Cursor and deploying the first agent, followed by a checklist for production. connic login prints a link and a confirmation code and waits while the login is approved in the browser, so coding agents can run it too. CLI reference
• •Runtime controls: The cleanup middleware hook runs after every completed, failed, or cancelled run, for example to release a lock taken in before. retry_options.attempt_timeout limits a single model request, 120 seconds by default. session.files: false leaves files from earlier runs out of a reused conversation. Middleware documentation
• •Larger deployments: A deployment can be up to 50 MB, with no separate limit for code. connic lint and connic test check test suites for schema errors and unknown agents before uploading.
• •Dashboard views: The Agents page has folder and flat views, search, and filters by type and status. Queued runs show why they wait, for example a schedule, a concurrency rule, or a budget limit. Connector logs can be searched, filtered by level, and scrolled back to older entries.
• •Guardrails: The PII guardrail no longer finds phone numbers inside card numbers, IBANs, or IP addresses, and prompt injection detection catches more ways of overriding instructions. When an agent's access settings block a database or Retrieval tool call, the run logs show a warning. Built-in guardrails
• •Large tool results: Screenshots and other files in tool results are no longer stored in the session history, and a tool result too large to store no longer fails the run.
• •Private networks: connic bridge now streams large requests and responses even when one side reads slowly, and routes async clients such as httpx and aiohttp. Email connectors verify mail server certificates and accept a private CA certificate on the Connection. Bridge documentation
• •API and connic MCP: REST responses return connector settings and trace metadata as objects instead of JSON strings, and the OpenAPI spec describes the fields and the permission each endpoint requires. connic MCP gained tools to read single approvals, A/B tests, channels, budget alerts, Connections, and files. REST API reference
• •Sign-in and support: The sign-in and registration pages have a new design, and registration sets up a passkey by default, with a password one click away. Questions sent through the new support chat on the website and in the dashboard are answered in the chat and by email.