The creator stack is quietly becoming an agent stack — and that changes how you schedule, repurpose, and ship
Most social media operators I know are running a Frankenstein workflow: a scheduler for publishing, a notes app for hook ideas, a repurposing tool for cutting one long video into six shorts, a spreadsheet for UTM tracking, and a browser tab graveyard of half-finished drafts. The AI layer — ChatGPT, Claude, Gemini — sits off to the side, disconnected from the actual publishing pipeline. That gap is the real story behind tools like Juggler, a new open-source agent workspace that launched on Product Hunt this week. On the surface it looks like a developer tool. In practice, it’s a preview of the workflow shape that creator-side AI tooling is heading toward: persistent sessions, tree-structured conversations, pluggable tools, and multi-device handoff. If you run social accounts for a living, that shape matters more than the specific product.
Here’s my thesis: the next wave of leverage for creators and social teams isn’t a better caption generator. It’s an agent that remembers your brand voice, holds context across a month of posts, and lets you branch a single idea into ten platform-native variants without losing the thread. Juggler is not a social media tool. But the design decisions its maker made — and the ones his early users are already pushing back on — are a useful mirror for what you should demand from the content tools you do pay for.
What Juggler actually is, and why a creator should care
Juggler is described by its maker, Julian Storer, as a code-agent workspace built after he got frustrated with existing terminal-based AI coding tools. His background is worth noting because it explains the design taste: he built the Tracktion DAW, the JUCE C++ framework, and the Cmajor DSP language. That’s a 30-year track record of building tools for people who stare at complex state all day — audio engineers, plugin developers, live performers. The instincts carry over.
The core pitch, per the launch page, is that you can see everything: tool calls, approvals, thread structure, item properties, even the raw context JSON, laid out in a Finder-style column view. Conversations are trees, not log files — any point can branch into a sub-thread, recursively. Sessions live in a database, so they survive quits, crashes, and reconnects. You can run it headless on one machine and attach from a desktop app and a phone browser simultaneously. Every tool the model can call is a JavaScript extension you can inspect, fork, or replace. It ships as a small Go binary — no Node, no Electron — and it’s free and open-source, Apache-2.0 for the extension SDK and AGPLv3 for the app. No signup. Bring your own LLM subscription or API keys.
Now, the honest framing: this is a one-man side project, not a funded startup. The maker says so himself. There’s no disclosed pricing because there isn’t any. There’s no disclosed user count, no funding round, no roadmap. What there is: a clear opinion about how AI work should feel, and two early comments from real users that already surface the friction points.
Why a social media operator should read a coding-tool launch at all
Because the underlying primitives are the same ones you need. When I schedule 30 posts across five platforms for a client, the failure mode isn’t the scheduler — it’s the context loss. The hook I wrote for TikTok doesn’t survive the trip to LinkedIn. The thread I drafted for X loses its thread when I try to expand it into a YouTube script. The UTM parameters get copy-pasted wrong because I’m working in three tabs and a Notion doc. Every one of those is a context problem, and every one of those is what tree-structured, persistent agent sessions are designed to solve.
Tools like Buffer, Hootsuite, Later, and Metricool have spent a decade solving the publishing half of this. They’re good at it. What they haven’t solved — and what most of them are now racing to bolt on with AI features — is the thinking half: the part where an idea becomes a cross-platform content plan that respects each platform’s native format. That’s the gap Juggler’s design is poking at, even if it’s aimed at developers.
How it differs from the incumbents you already pay for
Let me be precise about the comparison, because “AI content tool” is a meaningless category in 2025.
On the scheduling and publishing side, you have Buffer, Hootsuite, Later, Sprout Social, and Metricool. These are mature, API-integrated, and priced per seat or per channel. Their AI features — caption suggestions, hashtag generators, best-time-to-post — are shallow by design. They’re optimizations on top of a publishing workflow, not a rethinking of it.
On the content generation side, you have Jasper, Copy.ai, Writesonic, and the native AI features inside Canva and CapCut. These are prompt-in, draft-out. They don’t remember your last 20 posts. They don’t know your brand voice unless you paste it in every time. They don’t track which hook performed on which platform last quarter.
On the repurposing side, you have Opus Clip, Repurpose.io, Castmagic, and Descript. These are genuinely useful — I’ve used Descript for podcast-to-shorts workflows and Opus Clip for long-form-to-vertical cuts — but they’re single-purpose. They transform one asset into another. They don’t hold a strategy.
Juggler sits in none of these categories. It’s an agent workspace — a place where an AI model with tools can do multi-step work, and where you can see and edit every step. The closest analog in the creator space would be if you took Notion, gave it an AI agent that could call your scheduler’s API, and made every conversation branchable. That product doesn’t exist yet. But the primitives Juggler exposes are the ones you’d need to build it.
The feature that should make you jealous: sessions that survive
Here’s the detail from the launch page that I keep coming back to: “A session lives in a database, not in memory. If the agent was paused mid-run waiting for you to approve its next step, it’ll still be waiting after a relaunch, even if you connect from a different device.”
Now translate that to your workflow. You’re drafting a week of content on your laptop. You get halfway through a TikTok script, get pulled into a client call, close the lid. You open your phone on the train and pick up exactly where you left off — same context, same draft, same thread. You approve the next step from your phone. The agent continues. You get home, open the desktop app, and the work is there.
No current social media tool does this. Buffer syncs your queue, not your thinking. Notion syncs your docs, not your agent state. The reason is architectural: most tools store state in the browser session or in a server-side job queue that assumes a single client. Juggler stores it in a database and treats clients as views onto that database. That’s a small engineering decision with a large UX consequence.
My take: this is the single most underrated design choice in the launch, and it’s the one I’d most want to see copied by creator tools. The “I’ll finish this on my phone” workflow is real, and no scheduler I’ve tested handles it well.
The feature that should make you skeptical: everything is a plugin
The second design choice is more double-edged. Juggler makes every tool the model can call — including read, write, and bash — a JavaScript extension you can inspect, fork, or replace. Loop strategies, slash commands, and file viewers are also plugins. MCP servers and skills plug into the same document. The maker says juggler ext init scaffolds a working one in a command.
For a developer, this is catnip. For a social media manager, it’s a warning sign wrapped in an opportunity. The opportunity: if your scheduler has an API, you could theoretically write a Juggler extension that lets the agent draft, schedule, and track posts directly. The warning: the docs for writing a custom JS plugin are, by one early user’s own admission, thin. Gal Dayan commented on the launch page that he “ended up reading example plugins in the repo instead of following a guide” and asked for a “write your first tool” walkthrough. That’s a real gap, and it’s the kind of gap that determines whether a plugin architecture becomes an ecosystem or stays a curiosity.
What creators and social teams can borrow from Juggler’s design
You don’t need to install Juggler to learn from it. Here are the patterns worth stealing — and the ones worth demanding from the tools you already pay for.
Treat conversations as trees, not logs
The single biggest time sink in AI-assisted content work is scrolling back through a 400-message thread looking for the version of the hook that actually worked. Juggler’s answer is to make branching a first-class operation: any point can fork into a sub-thread, recursively. You can navigate, drill down, backtrack, duplicate, undo, re-open.
In practice, this is how good content strategy already works. You don’t write one caption; you write five variants and pick the best. You don’t build one content calendar; you build three and A/B test. The problem is that most AI tools flatten this into a linear chat, so the variants get lost. If you’re using ChatGPT or Claude for content work today, try manually branching: keep a “hooks” thread, a “captions” thread, and a “long-form” thread separate, and paste the winning hook from one into the next. It’s clumsy, but it’s the manual version of what Juggler automates.
Make every step visible and editable
Juggler’s Finder-style column view shows tool calls, approvals, thread structure, item properties, and raw context JSON. All of it is editable. That’s a direct rebuke of the black-box AI pattern — the one where you type a prompt, wait, and get a result you can’t inspect or correct mid-flight.
For social media operators, the analog is approval workflows. If you’re using an AI tool that generates 30 post drafts in one shot, you want to see why it chose each hook, which source material it pulled from, and what it’s about to publish. The ability to step in mid-run and redirect — which Tom Veber asked about directly in the comments, wondering whether the visual side lets you “step in mid-run and redirect it, or is it watch-only” — is the difference between an assistant and an autopilot. Autopilot is faster until it isn’t. Assistant is slower until it compounds.
Run headless, attach from anywhere
The “local, remote, or both at once” pattern is the one I’d most want in a scheduler. Run the agent on the machine where your assets live — your footage drive, your brand asset folder, your CMS — and attach from your laptop, phone, or a browser. One session, multiple live client views.
Today, if you want to schedule a post from your phone while your footage is on your desktop, you either upload everything to the cloud first or you wait until you’re back at your desk. A headless-with-attached-clients model collapses that. Buffer and Later have mobile apps, but they’re clients to a cloud queue, not views onto a session that lives where your work lives. Different architecture, different workflow.
Where my judgment says it falls short — and who it’s not for
Let’s be clear about the limitations, because the launch page is honest about them and I want to be too.
It’s not a social media tool. Juggler has no scheduling, no platform integrations, no analytics, no UTM tracking, no content calendar, no approval workflow for stakeholders. If you’re looking for a Buffer replacement, this isn’t it. It’s a workspace where an agent does work; the work it does depends entirely on the tools you plug in, and the social-media-specific tools don’t exist yet.
The plugin ecosystem is a promise, not a product. The maker says every tool is pluggable and that juggler ext init scaffolds a working extension in a command. That’s true as far as it goes. But as Gal Dayan noted, the documentation for writing a custom plugin is thin right now. Until there’s a “write your first tool” walkthrough and a library of community extensions, the pluggability is potential energy, not kinetic.
It’s a one-man side project. The maker says this explicitly: “This isn’t a huge team at a trillion-dollar AI company, it’s a one-man side-project.” That’s not a knock — some of the best tools in the creator economy started as one-person projects — but it’s a risk factor. Bus factor of one. No disclosed funding, no disclosed roadmap, no disclosed user count. If you’re a social media manager at an agency with 40 clients, you should not bet your workflow on it today.
The LLM dependency is real. Juggler brings your own subscription — Claude Code, Codex, Copilot, Gemini, Z.ai, Ollama, OpenRouter, DeepSeek — or your own API keys. That’s flexible, but it means your costs and capabilities depend on a third party. If you’re on a tight tool budget, factor that in.
Who it’s not for
If you publish to Instagram, TikTok, YouTube, X, LinkedIn, Facebook, Threads, and Pinterest and you want a single dashboard to schedule, track, and report — Juggler is not that and may never be that. Look at Metricool, Sprout Social, or Later instead. If you want an AI that writes captions in your brand voice without you pasting a style guide every time, look at Jasper or Copy.ai — and accept that they, too, have context limits.
If you’re a technical creator — someone who already writes scripts, automates with APIs, and thinks in workflows — Juggler is worth a download. It’s free, open-source, no signup. The risk is your time, not your money.
What I’d watch / test next
Here’s what I’d actually do this week, in order.
First, audit your context loss. Pick one piece of content you published in the last month. Trace it from idea to post. How many tools did it touch? How many times did you re-paste the same brand voice, the same audience note, the same CTA? That number is your context tax. If it’s higher than three, you have a problem worth solving — and it’s the problem agent workspaces are designed for.
Second, test the tree workflow manually. In ChatGPT or Claude, start a thread called “content tree.” Put your core idea at the top. Branch into three sub-threads: one for TikTok hooks, one for LinkedIn angles, one for YouTube script beats. See how it feels to navigate back and forth. If the branching helps, you’ve just validated the Juggler design pattern without installing anything.
Third, if you’re technical, download Juggler and try one extension. The launch page says juggler ext init scaffolds a working one in a command. Try wrapping a single API call — your scheduler’s “create draft” endpoint, your analytics “pull last 7 days” endpoint, whatever. You’ll learn more in an hour about where agent tooling is heading than you will from a month of reading launch posts.
Fourth, watch the docs. The single biggest signal to track is whether the maker ships the “write your first tool” walkthrough that Gal Dayan asked for. If he does, and the community starts publishing extensions, this becomes a platform. If he doesn’t, it stays a power-user tool. That’s the fork in the road, and it’s worth checking back in 30 days.
The broader bet — and this is my take, not a sourced fact — is that within 18 months, the distinction between “scheduler” and “AI agent” collapses. Buffer, Hootsuite, and Later will either build or acquire agent-style context management, because their users will demand it. The question for you, as an operator, is whether you wait for that to happen or start building the muscle now. Juggler is one way to build the muscle. It’s not the only way. But it’s a useful mirror for what your current stack is missing — and that’s worth more than the tool itself.
