Overview
Connect your agents to the outside world. Connectors enable your agents to receive triggers, send results, and integrate with external systems.
Connect agents to any system
Connectors are integration points that define how agents are triggered, how they receive input, and where they send results. Each connector can be linked to one or more agents. When triggered, it dispatches the input to all linked agents.
Multi-Agent Linking
Connect one trigger to multiple agents simultaneously
Multiple Modes
Inbound, outbound, and sync integration patterns
Secure by Default
Built-in authentication and encryption for all connectors
How to Add a Connector
The setup flow is the same for every connector type. You always start from the agent you want to connect:
Open your agent
Go to Agents in the sidebar and click on the agent you want to connect.
Add a connector
In the Connector Flow section, click Add inbound connector or Add outbound connector, then click Create New Connector in the drawer that opens.
Choose type and mode
Select a connector type from the marketplace (HTTP Webhook, Kafka, Cron, etc.), then choose a mode and fill in any connector-specific settings.
Create and copy credentials
Click Create. The detail drawer opens automatically with credentials (URL, secret) in the Configuration section. To view them later, hover over the connector in the Connector Flow and click the Eye icon.
The same connector can be linked to multiple agents, so one trigger fans out to all of them. You can link or unlink agents later from the connector detail drawer.
Connector Modes
Connectors operate in one of three modes, each designed for different integration patterns:
Inbound
Fire-and-forget async triggers
Outbound
Deliver results externally
Sync
Request-response pattern
Inbound Mode
Fire-and-forget triggers for asynchronous agent runs
Inbound mode is designed for fire-and-forget scenarios. When an inbound connector receives a request, it immediately queues the agent run and returns a response with the run ID.
Best for:
- Background processing tasks
- High-volume webhook ingestion
- Event-driven architectures
- When you don't need immediate results
Response:
{"status": "ok", "run_ids": ["uuid-1", "uuid-2"]}Outbound Mode
Deliver agent results to external destinations
Outbound mode sends agent results to an external URL when runs complete. This is useful for integrating with external systems that need to receive agent outputs.
Best for:
- Sending results to external APIs
- Integrating with third-party services
- Building event pipelines
- Notifying external systems
Outbound Payload:
{
"run_id": "uuid",
"agent_name": "my-agent",
"status": "completed",
"output": "Agent response..."
}Sync Mode
Request-response pattern with immediate results
Sync mode waits for the agent to complete and returns the result in the same HTTP response. This provides a traditional request-response pattern.
Best for:
- REST API integrations
- Interactive applications
- When you need immediate results
- Short-running agent tasks
Response:
{
"status": "ok",
"result": {
"run_id": "uuid",
"output": "Response..."
}
}Default timeout is 5 minutes. For longer tasks, use Inbound mode with an Outbound connector.
What Agents Receive as Input
When a connector triggers an agent, the incoming data is passed as the agent's input. The exact format depends on the connector type:
HTTP Webhook
The entire JSON body is passed as the agent's input. Form data fields become key-value pairs. Uploaded files are extracted and sent as inline data to the LLM.
Apache Kafka
The message value is parsed as JSON and passed to the agent. A _kafka metadata object is appended with topic, partition, offset, timestamp, and key.
Cron
The configured prompt string is passed as the agent's input. If no prompt is set, the agent receives an empty payload.
See each connector's documentation page for the full payload format and examples.
Retrieving Results from Inbound Runs
Inbound connectors return immediately with run_ids without waiting for the agent to finish. To get the actual agent output, you have two options:
Add an outbound connector
Link an outbound webhook or Kafka producer to the same agent. When the run completes, the result is automatically pushed to your configured destination.
Check the dashboard
Open the run in the Logs tab to inspect the full output, execution traces, and token usage.
Sync Mode: End-to-End Example
This walkthrough shows how to create an HTTP endpoint that accepts a query and returns an AI-generated response using sync mode.
Define your agent
version: "1.0"
name: question-answerer
type: llm
model: gemini/gemini-2.5-flash
system_prompt: |
You answer user questions concisely and accurately.
output_schema: answer.jsonCreate a sync webhook
Follow the How to Add a Connector steps above: open your agent, click Add inbound connector in the Connector Flow, then Create New Connector, select HTTP Webhook, and choose Sync (Request-Response) mode.
Get your webhook URL and secret
Click the icon on the connector in the flow to open its details. Copy the Webhook URL and Secret Key.
Send a request
curl -X POST <webhook-url> \
-H "Content-Type: application/json" \
-H "X-Connic-Secret: <your-secret-key>" \
-d '{"question": "What is the capital of France?"}'The response waits for the agent to finish and returns the result:
{
"status": "ok",
"result": {
"run_id": "550e8400-e29b-41d4-a716-446655440000",
"agent_name": "question-answerer",
"status": "completed",
"output": "{\"answer\": \"Paris\"}",
"error": null
}
}Call from Python with error handling
import requests
url = "<webhook-url>"
secret = "<your-secret-key>"
resp = requests.post(
url,
json={"question": "What is the capital of France?"},
headers={"X-Connic-Secret": secret},
timeout=300,
)
resp.raise_for_status()
data = resp.json()
result = data["result"]
if result["status"] == "failed":
raise RuntimeError(f"Agent failed: {result['error']}")
print(result["output"])Sync mode has a 5-minute timeout. For longer-running tasks, use an inbound webhook to trigger the agent and an outbound webhook to receive the result.
Ready to connect?
Add a connector to your agent directly from the agent detail page. HTTP Webhooks are a great place to start as they let you trigger agents from any system that can make HTTP requests.