Skip to main content

​
What is an Agent?

An Agent in OpenSink is a registered entity that represents an AI agent you run in production. It is the anchor point for everything else:
  • Sessions track its executions
  • Configurations control its behavior
  • Activities log what happened
  • Input Requests enable human interaction
OpenSink does not run your agent. It gives your agent identity, state, and control.
OpenSink is framework-agnostic. Your agent can be built with LangChain, CrewAI, custom code, or anything else. OpenSink doesn’t care how it runs — only that it has structure.

​
Why register agents?

Without a central record, production agents become invisible:
  • Which agents exist?
  • What are they configured to do?
  • Are they running right now?
  • Did they fail?
  • What did they produce?
Registering an agent in OpenSink answers all of these.

​
What an Agent contains

FieldDescription
nameHuman-readable name
descriptionWhat this agent does
statusCurrent state — derived from its latest session
config_idActive configuration version
execution_endpointOptional webhook for resuming execution
Status is automatically kept in sync with the agent’s latest session.

​
Agent status

An agent’s status reflects what its most recent session is doing:
StatusMeaning
runningAgent is actively executing
waiting_for_inputPaused, waiting for human input
processing_inputInput received, resuming execution
completedLatest session finished successfully
failedLatest session failed
You don’t set this manually. It updates automatically as sessions progress.

​
Creating an Agent

curl -X POST https://api.opensink.com/api/v1/agents \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "name": "Finance News Agent",
    "description": "Monitors financial news and writes summaries to a sink"
  }'
When you create an agent, OpenSink automatically:
  1. Creates the agent record
  2. Creates a default configuration (empty schema and values)
  3. Links the agent to that configuration
Your agent is ready to run sessions immediately.

​
How Agents connect to everything

An Agent is the central hub. Here’s how the pieces fit together:

Configurations

Versioned settings that control agent behavior — prompts, parameters, tool selections.

Sessions

Durable execution records. Each run creates a session that tracks state and status.

Input Requests

Schema-driven prompts that pause execution and wait for human input.

Activities

A log of everything that happened during a session — starts, messages, inputs, results.

​
The typical agent loop

Most agents follow this pattern:
1

Agent starts

Your code creates a session via the API. Status becomes running.
2

Agent does work

Reads data, calls LLMs, makes decisions. Logs activities along the way.
3

Agent produces results

Writes items to sinks — the durable output of its work.
4

Agent needs input (optional)

Creates an input request. Execution pauses. A human responds.
5

Agent completes

Updates the session to completed. Status propagates to the agent.

​
What Agents are not

Agents in OpenSink are not:
  • an execution runtime
  • a framework
  • a prompt chain
  • a workflow engine
OpenSink does not decide what your agent does or how it runs. It provides the infrastructure to make your agent observable, configurable, and controllable in production.

​
When to use Agents

Register an agent in OpenSink when:
  • it runs in production (not just notebooks)
  • you need to track its executions
  • its behavior should be configurable without redeploying
  • humans need to interact with it
  • you need to know what it did and when
If your agent matters — register it.