You’ve seen this movie before. A shiny new SDK drops on GitHub. It’s MIT-licensed. It promises to bring your AI agents into Slack and Microsoft Teams as native participants — dynamic UI, natural conversation flow, the works. The README is clean, the demo is slick, and the community starts buzzing.
Then you read the comments.
“The MIT part is just the client. The service that actually makes it run is closed and license-gated.”
And there it is. The trap door hidden under the welcome mat.
The Channels SDK from CopilotKit is genuinely impressive on the surface. It’s built on top of AG-UI, so any agent that emits AG-UI events can be wired into Slack or Teams. Agents don’t just post messages — they generate UI components, react in real time, and behave like actual team members. If you’re building enterprise AI agents, this is the kind of thing that makes you sit up straight.
But here’s what the Show HN thread revealed, and what most people scrolling past the GitHub stars will miss: the open-source client is the front door. The engine room is locked.
The backend service — the thing that actually orchestrates agent communication, manages state, and makes the whole system function — is proprietary. License-gated. Hosted. You cannot self-host the core. You can read the client code, modify it, fork it. But without the backend, it’s a steering wheel with no engine.
Open source isn’t a license file. It’s a promise that you control the software you run. Break that promise, and you’re just selling freemium with a GitHub URL.
This isn’t a bug. It’s a strategy — and a familiar one.
LangChain did something similar. They open-sourced the framework, built a massive ecosystem of contributors and integrations, and then monetized the hosted infrastructure layer. The community built the moat; the company collected the rent. It worked brilliantly. It also left plenty of developers feeling like they’d been used as free labor for a VC-backed land grab.
The Channels SDK follows the same playbook. The MIT-licensed client is a loss leader. It’s designed to build adoption, create dependency, and funnel users toward the proprietary hosted service where the real money — and the real control — lives. The open-source label isn’t a lie, technically. It’s just strategically incomplete.
And look — maybe that’s fine for you. If you’re a team that wants to ship AI agents into Slack fast, without managing infrastructure, without worrying about scaling, without standing up your own orchestration layer — the Channels SDK and its hosted backend might be exactly what you need. Convenience has value. Speed to market has value. Not every project needs to be ideologically pure.
But you should walk in with your eyes open.
The question isn’t whether the tool works. It’s whether you’re comfortable building your entire agent infrastructure on a foundation you can never fully own.
Because here’s what happens at scale: your agents become tightly coupled to the Channels SDK’s backend APIs. Your UI components are built for their rendering pipeline. Your workflows assume their state management. And when pricing changes — and it will, because pricing always changes — you’ll discover that the “open source” client you forked is useless without the proprietary service it was designed to talk to.
Vendor lock-in doesn’t announce itself. It shows up as convenience, as documentation that’s just a little too good, as a developer experience that’s just smooth enough to make you stop asking questions. By the time you realize you’re locked in, you’re already too deep to leave cheaply.
The Channels SDK team — to their credit — was transparent when pressed in the HN comments. They didn’t hide the closed-source backend. But the GitHub repo, the MIT license, the “open source” framing? That framing does a lot of heavy lifting before anyone scrolls down to the comments. Most people won’t.
Transparency buried in a comment thread isn’t transparency. It’s plausible deniability with extra steps.
So here’s the real takeaway for anyone building AI agents for enterprise communication: the Channels SDK is a legitimate tool with a clever architecture and a smart go-to-market strategy. It might even be the right choice for your team. But it is not open source in the way that word implies. It’s a platform play wearing open source as a costume.
Treat it that way. Evaluate the hosted service on its pricing, its reliability, its roadmap — not on the warmth you feel when you see “MIT License” at the top of a README. Because that warmth is exactly what the strategy is designed to produce.
And if you do choose it, build an exit strategy on day one. Abstract the agent logic. Keep your core workflows portable. Document the coupling points. Because the day will come when you need to leave, and the only thing that will save you is the work you did before you needed it.
The best time to plan your exit from a platform is the day you enter it. The second best time is right now.
FAQ
Q: Is the Channels SDK actually open source?
A: Only the client is MIT-licensed. The backend service that actually runs the agents is closed-source and license-gated. You can read and fork the client, but you can't self-host the core engine that makes it work.
Q: Should I use it for my enterprise AI agents?
A: If you prioritize speed and convenience over full control, it's a solid choice. But if vendor lock-in is a dealbreaker for your organization, the proprietary backend makes this a non-starter unless you're willing to build an exit strategy from day one.
Q: Isn't this the same playbook LangChain used?
A: Exactly. Open-source the framework to build ecosystem adoption, then monetize the hosted infrastructure layer. It's a proven go-to-market strategy — effective for the company, but it means the community builds the moat while the company collects the rent.