Writing Design Taste into an Agent: Four Months of Building LangChain's Open-Source Content Studio
Over four months, LangChain's internal GTM engineering and design team turned Content Studio (the Design Agent that lives in Slack) from "ugly, looks like generic AI output" into something that can produce work at scale. They encoded designers' judgment into skills, a wiki, and code gates; gave the model a sandbox computer that can modify projects across turns; and used asynchronous sub-agents plus collaborative multi-person threads to support hours-long tasks. They have also open-sourced the entire harness, which you can fork, attach your own brand to, and deploy to your team's Slack via Managed Deep Agents.
Open-source repository:
https://github.com/langchain-ai/design-agent
Project background and results
The company moves fast: launches, events, and blogs all need graphics, images, intro videos, and ad assets, and the design team's capacity is consumed by repetitive requests. Content Studio lets you describe a request in Slack, attach a brief or assets, and get back compliant finished pieces. According to the write-up, since August it has delivered 3,000+ assets (including 80+ PPTs); posts featuring its output have reached about 4.5 million impressions on X; on the official account, these posts get roughly 2× the likes and 3.7× the bookmarks of other posts; about 3/4 of requests come from teams outside marketing; and 75% of users return weekly. The median model spend per request dropped from about $8 in mid-September to about $0.50; after moving to Managed Deep Agents, the team's own code shrank by about 80%.
Can AI do design?
Models can already write HTML/CSS, chart specifications, and animation timelines. What they lack is a point of view and context, so they tend to "converge to the distribution," producing work that looks fine but is indistinguishable from thousands of others. The article cites Anthropic's framing and Stripe design lead Katie Dill's notion of "zombie UI": without a point of view, AI will make one up for you. The conclusion is not that "AI can't design"; it's that you have to teach it your taste.
How do you teach taste?
- Basics: color palettes, font weights, spacing, alignment.
- More critical: design principles (such as one focal point per frame), guardrails against AI clichés, and the reasoning behind each piece of feedback (not just "change this").
- Measurable criteria are enforced with code gates (such as default capitalization); subjective judgments (whether the idea is strong enough, whether the information is clear) are decided by designers and written into skills for reuse.
- An early motion example: a bird dragging a light trail out of frame. The instruction "no sharp corners" was interpreted as hard cuts with rounded corners. Later, the agent built its own frame-by-frame checks to ensure the light trail followed the motion. The designer's role shifts toward creative director: setting direction and reviewing work, rather than hand-crafting every piece.
The media harness: the designer's computer
The foundation is Deep Agents (planning, files, sub-agents, context management). Managed Deep Agents handles production operation (Slack, LangSmith Sandbox, tools, memory, scheduling). Key points on the environment side:
- One sandbox per Slack thread: an isolated Linux environment with its own filesystem, where the project persists across turns. Outputs are preferably code (slide HTML, animation timelines), so changing a timing point just re-renders, without regenerating the whole piece.
- Tool layer: for editing, HeyGen's open-source HyperFrames (treating the video as a web page plus a GSAP timeline); for original animation, an in-house motion-studio (drawing frames pixel by pixel, blending multiple moments to simulate motion blur, etc.); audio and visuals share the same timeline.
- Knowledge in four layers: Skills (routed by task; the article says about 48 skills and nearly a thousand files, while the README says about 35, so the repository's current state is authoritative); Wiki (brand, tone, products, breakdowns of about 70 reference videos, etc., where skills link to content instead of copying it); Gates (deterministic checks); Memory (team-level and personal-level; the AGENTS.md index once bloated to about 500k tokens, and is now capped at about 200 lines).
- Spec-driven workflow: the expensive part is the final piece, so first storyboard (exploring at about 50ms per frame), then animatic to lock pacing, then produce at scale. The order is enforced by code, while judgment stays in the prompt. The collaborative canvas uses Paper (point-and-click editing rather than describing coordinates in natural language throughout); Paper's desktop capabilities run headlessly on a persistent Linux worker and are bridged to cloud sandboxes.
The main agent coordinates and dispatches work
In long tasks, multiple people change the brief while work is underway. Synchronous sub-agents would block the main thread, so sub-tasks run asynchronously: the main agent breaks down work, assigns roles, and selects models and effort levels, coordinating through start_task / check_tasks / cancel_task / resume_task / report_progress / schedule_wakeup. Human messages can be inserted before the next model call. The thread continuously updates the plan, ETA, sub-task status, and spend, and public release requires approval. One example: an overnight reskin of a 52-page PPT, where the main agent ran for about 1 hour while sub-agents collectively ran for over 6 hours, without blocking the conversation.
The Bitter Lesson
Early on, the team piled roughly 115 reusable UI/animation components and detailed rules onto a weaker model. The brand stayed consistent, but layouts became repetitive. After a model jump (the article names Opus 5.5), they deleted most of the hardcoded patches and kept only principles and high-level guidance, and diversity improved. Rules that compensate for model weaknesses expire; what lasts longer is the environment: tools, context, and how humans intervene midway.
Self-improvement
Fast loop: write rules into memory on the spot. Slow loop: learn_from_job extracts up to 5 evidence-backed lessons and attaches them to the relevant skill; later tasks are scored, and skill/wiki updates are merged weekly in the background. Next direction: the full campaign lifecycle (after approval, posting via Buffer, employees forwarding drafts, scheduled retrospectives), with humans still reviewing and approving.
Open source and deployment
design-agent: fork it, add brand tokens, fonts, and skills, and deploy to Slack with Managed Deep Agents. The README emphasizes local trial and keeping secrets out of the sandbox. The architecture diagram links Slack → main agent → skills/wiki/memory → sandbox (Chromium, ffmpeg, HyperFrames, motion-studio, asynchronous sub-agents).