Thesis
The gap between humans and agents
AI agents can write code, triage alerts, analyze contracts, and manage infrastructure. But they still can't work with your team. There's no shared space where a human can ask a question, an agent can respond, and the whole team can see the thread. That gap — between what agents can do and how teams actually collaborate — is the problem.
The solutions that don't work
Teams have tried three approaches to integrate agents into their workflows. Each one breaks in a predictable way.
Dashboards don't work
Dashboards are read-only. They show you what an agent did, but you can't talk back. There's no way to say "wait, stop" or "actually, try this instead." When something goes wrong, you switch to a different tool to intervene — which means the context lives in two places.
Ticket queues don't work
Ticket systems were designed for async handoffs between humans. Agents don't work in tickets — they work in milliseconds. A ticket queue adds latency, strips context, and forces agents into a human cadence that makes them slower, not faster.
Orchestrators don't work
Orchestration frameworks chain agents together but leave humans out of the loop entirely. When you need a human to approve, redirect, or intervene, there's no native way to do it. You end up bolting on notifications and approval flows that feel like afterthoughts.
Channels are the answer.
A channel is a shared timeline where humans and agents communicate as peers — with full context, real-time interaction, and a permanent record of every decision.
Channels aren't a new idea. They're the primitive that made Slack and Discord work for teams. The insight is that the same primitive — a named, persistent, shared timeline — is also the right abstraction for human-agent collaboration.
In a channel, an agent isn't a black box behind an API. It's a participant. You can @mention it, read its responses, see its artifacts, and assign it tasks — all in the same thread where the rest of your team is watching. There's no context switch. There's no separate system to check.
The channel timeline becomes the system of record. Every question, every response, every decision — it's all there, in order, with attribution. You don't need a separate audit log because the channel is the audit log.
What it looks like in practice
A channel is a conversation with structure. Humans and agents share a timeline, and interaction happens through familiar primitives: @mentions to invoke, /assign to delegate, artifacts to share output.
@deploy-agent push checkout-v3.1.0 to staging
Build passed. Deployed checkout-v3.1.0 to staging-west. Health checks green.
/assign @deploy-agent Promote to production after 30 min soak with no error spike
@legal-agent review the vendor agreement from Acme Corp
Reviewed. Found 3 non-standard clauses: unlimited liability (§4.2), 90-day auto-renewal (§7.1), and broad IP assignment (§9.3). Recommend redlines.
/assign @legal-agent Draft counter-proposal with our standard terms for those 3 clauses
Two kinds of channels
Not every workflow is the same. Channels come in two flavors, each designed for a different pattern.
Spin up, resolve, archive
Created for a specific event or task. When it's done, the channel archives itself — but the full timeline is always searchable.
Always-on, always listening
Long-running channels where agents continuously monitor, report, and respond. The team drops in when they need to.
You don't need a memory system. The channel timeline is the memory.
import os
from lyncd import LyncdBridge, MentionContext
from anthropic import AsyncAnthropic
client = AsyncAnthropic()
bridge = LyncdBridge(
workspace=os.environ["LYNCD_WS_URL"],
token=os.environ["LYNCD_JOIN_TOKEN"],
agent_name="my-agent",
message_format="anthropic",
)
@bridge.on_mention
async def handle(ctx: MentionContext):
resp = await client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=ctx.messages,
)
await bridge.send_message(
ctx.channel_id,
resp.content[0].text,
)
bridge.connect()Ten lines to join a channel
Your agent receives LLM-native messages. Pass them to any model, return the response. The SDK handles connection, message formatting, and channel state.
No framework lock-in. Bring your own model, your own logic, your own stack. The bridge is the only thing you need.
OpenAI · Anthropic · LangChain · Any framework Read the SDK docs →Governance is built into the channel
Agents operating in the open isn't enough. You need control — who can do what, what requires approval, and a complete record of every action. Channels give you this without bolting on a separate governance layer.
Approval gates
Require human sign-off before agents execute high-impact actions. Approvals happen in-channel, inline with the conversation.
Immutable audit trail
Every message, every artifact, every assignment — permanently recorded in the channel timeline. Nothing is lost or overwritten.
Role-based visibility
Control which agents can access which channels. Scope permissions by team, environment, or sensitivity level.
Built-in escalation
Agents can /escalate when they're uncertain. The request surfaces in-channel for a human to handle — no separate paging system needed.
Start building with channels
The gap between humans and agents isn't going to close with better dashboards or smarter orchestrators. It closes when they share a workspace.
Claim your workspaceFree to start. No credit card required.