Skip to main content
Connic

Your code. Your agents.
Running in the EU.

Build AI agents in YAML and Python and release changes through Git. Connic connects them to your systems and handles operations. Testing, observability, human approvals, and managed models with EU hosting are available on the same platform.

Start for freeTalk to Sales
Build the first agent
Pipeline
  1. Build imagedone
  2. Run testsdone
    1/1 · 100%
    order-support::looks_up_an_order
    1/1
  3. Release to productiondone
The test defined in tests/order-support.yaml runs before the production environment changes.

What your team builds and what Connic handles

Agents, tools, and tests stay in your repository. For deployment, operations, and EU hosting, Connic provides the capabilities your team would otherwise need to assemble and operate.

What your team builds and what Connic handles
FeatureFramework with your own infrastructureConnic
Agent codeFramework-specific PythonYAML and Python
Multi-agent orchestrationConfigured in the applicationSequential and delegated agents
DeploymentYour own deployment pipeline and runtimeGit- or CLI-triggered deployment
Tests before releaseYour own checks before releaseTests as part of deployment
Production operationsOperations and monitoring managed by your teamManaged execution with observability
Data processing in the EUDepends on selected servicesEU project region and EU hosting for connic/* models

From an order question to a tested agent

The agent file defines the behavior, a Python tool retrieves order data, and a test checks that the agent uses the tool. All three files live in the same repository. A push to the mapped branch tells Connic to build the image, run the tests, and release the new version if they pass.

agents/order-support.yaml
version: "1.0"

name: order-support
type: llm
model: connic/gpt-5.6-sol
description: "Resolve order questions and delegate refunds"

system_prompt: |
  Help customers understand an order.
  Look up the order before answering.
  Delegate refund requests to the refund agent.

tools:
  - orders.lookup
  - trigger_agent

guardrails:
  input:
    - type: prompt_injection
      mode: block
tools/orders.py
import os
import httpx

async def lookup(order_id: str) -> dict:
    """Return the current status of one order."""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{os.environ['ORDERS_API_URL']}/orders/{order_id}",
            headers={"Authorization": f"Bearer {os.environ['ORDERS_API_KEY']}"},
        )
        response.raise_for_status()
        return response.json()
tests/order-support.yaml
version: "1.0"

tests:
  - name: looks_up_an_order
    payload: '{"message":"Where is order A-1042?"}'
    expected_result: status == "completed"
    expected_tool_calls:
      - orders.lookup: invocations >= 1
Branch-to-environment mapping
main → production

Tests check the change before release

A push to main starts deployment to production. Connic builds the image and runs tests/order-support.yaml. If the suite passes, the new version becomes active. Projects without a Git connection release changes through the CLI.

You can then use the dashboard to inspect the tools the agent called, how long execution took, and the token costs incurred.

More guides: deployment tests, deployment, and Python agents without Kubernetes.

Plan for your agents’ data to be processed in the EU

Choose an EU region for your project and use connic/* models with EU hosting. To keep all processing in the EU, the model providers and external services you connect must meet the same requirement.

German company and contract
Connic is based in Munich and contracts through a German entity. Procurement and legal teams can review the DPA and check the current subprocessor list.
EU hosting for your project and AI models
Choose an EU region when creating your project. Requests to connic/* models are processed exclusively in the EU. If that is not possible, Connic stops the request.
Keep external processing in the EU as well
To keep all processing in the EU, your model providers, tools, guardrails, judges, and connected systems must also process data exclusively there. Managed AI models with EU hosting.
Prepare your AI systems for review
With Connic Enterprise, you can document measures and incidents for your AI systems and export the supporting evidence. These records support review; they do not replace legal advice, final classification, or certification. AI Governance capabilities.

From your first agent to ongoing operations

Guides and capabilities for development, testing, observability, and AI governance.

Composer SDK

See how YAML agents and Python tools fit together.

Tools & orchestration

Add Python tools, built-ins, or MCP servers.

Models

Managed models with EU hosting and your own model providers.

Testing

Run assertions and judges before deployment.

Observability

Inspect runs, traces, latency, token use, and cost.

EU AI Act readiness

Document measures, incidents, and evidence for review.

Code-first platform questions

You define your agents’ behavior in YAML and write their tools and middleware in Python. The code lives in Git alongside the tests, so your team can review and version changes. Connic handles deployment and operations and provides capabilities such as observability and human approvals.

No. Connic is for teams that want to build agents with YAML, Python, and Git. The dashboard supports that workflow: it lets you manage projects, configure connections, and inspect runs. Agents and their logic stay in the repository.

You build your agents in code with the Composer SDK. Connic also handles deployment, execution, and scaling. Testing, traces, guardrails, human approvals, retrieval, sessions, and a database are built in. Your team can use these capabilities without assembling and operating separate services.

Keep the agent configuration, Python tools, and tests in your repository. If your project is connected to Git, a push to the mapped branch starts deployment. Connic builds the image and runs any available tests. If a test fails, the new version is not activated. Without a Git connection, you can start deployment through the CLI.

Yes. You can run agents in a fixed sequence or delegate specific tasks. With trigger_agent, one agent assigns work to another in the same project. With trigger_agent_at, the task can be scheduled for later. The trace also lets you inspect the delegated agents’ runs.

You can run your project in an EU region. Requests to connic/* models are processed exclusively in the EU. To keep all data in the EU, your own model providers, tools, and connected services must meet the same requirement.

With Connic Enterprise, you can document measures and incidents for your AI systems and export evidence. This supports preparation and review but does not automatically make an AI system compliant. Legal advice, final classification, and certification are not part of the product.