What We Shipped in April 2026

In April, we focused on giving teams more control over agents in production. Pause runs for human approval before destructive tool calls, reach private services from any custom code through the Bridge, hook into every tool call, plug in any OpenAI-compatible model, and watch logs from application code stream into the dashboard live.

Human-in-the-Loop Approvals

Some tool calls should never run unattended. With the new approvals system, teams can pause an agent before any tool marked as sensitive and require a human to approve or reject the call from the dashboard.

approval:
  tools:
    - order_tools.cancel_order                                  # always
    - order_tools.process_refund: param.amount > 50             # conditional
  timeout: 600
  message: "This order action requires manager approval."
  on_rejection: continue   # let the agent adapt instead of failing

• •Conditional gates: Request approval only when an expression matches, e.g. refund amount over a threshold, or a non-admin caller
• •Timeouts: If no decision arrives in time, the run fails. With on_rejection: continue, the rejection is fed back to the agent so it can adapt instead
• •on_rejection: Choose whether a rejection ends the run (default) or feeds back to the agent so it can pick another path
• •Approvals page: A dedicated dashboard view lists every pending request with the tool name and parameters, plus a direct link to the agent and approve/reject actions

The full walkthrough is in Human-in-the-Loop Approvals for AI Agents.

Bridge: Now for Custom Tools and Private Services

The Connic Bridge used to be just for connectors. It now extends to every piece of code in a Project: custom tools, middlewares, tool hooks, and custom guardrails, plus custom LLM providers. Reach a Postgres, an internal API, or a self-hosted inference endpoint that lives only inside a private network, without changing the client library.

Address private services with a magic hostname and the runtime tunnels the connection through the named bridge:

import psycopg
from connic import bridge_host

async def lookup_order(args, context):
    # postgres-primary lives in a private VPC, only reachable via the bridge
    dsn = f"postgresql://app:secret@{bridge_host('abc123', 'postgres-primary')}:5432/orders"
    async with await psycopg.AsyncConnection.connect(dsn) as conn:
        async with conn.cursor() as cur:
            await cur.execute("SELECT * FROM orders WHERE id = %s", (args["order_id"],))
            return await cur.fetchone()

Projects can also run multiple named bridges side by side, one per environment or private network, and individual connectors and LLM providers can pick which bridge they route through. Further background is in Connic Bridge: Agents in a Private Network.

Tool Hooks

Run application code before and after every tool call with tool hooks. Validate or rewrite parameters, enforce access control, log usage, or transform results, all without touching the tools themselves.

from connic import AbortTool

async def before(tool_name, params, context):
    # Block deletions for non-admin callers
    if tool_name == "delete_order" and not context.get("is_admin"):
        raise AbortTool({"error": "Permission denied"})

    # Normalise IDs so the LLM can be sloppy
    if "order_id" in params:
        params["order_id"] = params["order_id"].upper()

    return params

async def after(tool_name, params, result, context):
    print(f"[hook] {tool_name}({params}) -> {result}")
    return result

Drop a Python file in the hooks/ folder named after the agent (e.g. hooks/order-manager.py) and the SDK picks it up. Raise AbortTool from before to skip the call entirely and feed a structured response back to the model.

Discoverable Tools

Loading dozens of rarely-used tools into every prompt burns tokens and pushes the model towards wrong choices. With discoverable tools, the configuration lists the tools an agent should always have alongside a much larger pool that gets indexed for search instead. The agent finds them at runtime with a natural-language query.

tools:
  - order_tools.lookup_order        # always loaded
  - order_tools.process_refund

discoverable_tools:
  - reporting.*                     # 40 reporting helpers, indexed not preloaded
  - support_tools.*

mcp_servers:
  - name: github
    discoverable: true              # MCP server tools indexed for search

Discoverable tools use the same syntax as regular tools (wildcards, conditional expressions, everything) and work for both local functions and tools exposed by an MCP server.

AI Dashboard Builder

Describe a dashboard in a prompt and Connic builds it. Open a dashboard in edit mode and use the AI bar at the bottom to add or change widgets in plain English. "Show P95 duration for the order-manager agent over the last 7 days" or "group runs by customer_tier as a bar chart."

Every prompt creates an undo step, so teams can iterate quickly and roll back any change with Cmd+Z without losing the rest of the layout.

Custom OpenAI-Compatible LLM Providers

Bring any model. Any OpenAI-compatible endpoint (vLLM, Ollama, a LiteLLM proxy, an internal inference gateway) can now be added as a custom LLM provider. Open Project Settings > LLM Provider, click Add Custom Provider, give it a unique prefix and a base URL, and use it from any agent like a built-in:

# Custom provider configured with prefix "ollama"
model: ollama/llama3

# Custom provider configured with prefix "vllm"
model: vllm/mistral-7b

If the endpoint lives inside a private network, pair it with the Bridge and pick a bridge in the provider's Route via Bridge dropdown. Every request from every agent is tunneled through the selected Bridge.

Live Logs From Application Code

Custom code is no longer a black box. Anything a tool, middleware, hook, or guardrail writes with print or logs now streams into the project's Logs tab in real time. A source tag identifies the emitting component.

• •stdout, stderr, and stdlib logging: All three are captured. No special SDK calls needed
• •Tracebacks on crashes: Unhandled exceptions in application code are logged with the full traceback for debugging without a redeployment
• •Filtering: Slice the Logs tab by agent, log level, or source

More Improvements

• •Project overview dashboard: Every project gets an auto-provisioned Overview dashboard embedded right on the project home page, with a curated set of health metrics, charts, and recent runs
• •Live streaming run traces: A live indicator shows when a run is still in flight, and trace steps stream in incrementally as the agent works. Plus a new graceful termination flow for stopping long runs cleanly
• •Flexible run filtering: Filter run tables and dashboard widgets with expressions like context.customer == 'acme' or output.sentiment == 'positive', and group bar charts by any run_context field
• •Dashboard reordering & navigation: Reorder dashboards from project settings, see them prominently in the project sidebar, and create new ones from a dedicated drawer
• •Wildcard tool patterns: Reference whole modules in one line with patterns like calculator.* for local tools or api:my_api.users_* for API spec tools
• •Git monorepo support: Set a Repository root directory in project settings so Connic builds from the subdirectory where the SDK files live, not the repo root