langchain-ai/design-agent

What it is

Content Studio is the design agent that LangChain runs internally, now released as open source under the name design-agent. It's an AI assistant you can deploy to your team's Slack: anyone can ask it like they'd ask a human designer, attach files, and get finished, on-brand deliverables back — from a resized ad to a launch film.

LangChain's own numbers: over 3,000 assets shipped since August, ~4.5M views on X from posts featuring its work, and 3 in 4 requests come from outside the marketing team.

How it works

The agent is built on Deep Agents and deployed via Managed Deep Agents (MDA), which handles the infrastructure: Slack integration, sandboxes, memory, schedules, and tracing. This repo is the design brain on top — the model makes creative decisions, while code handles rendering, checking, and delivery.

Key mechanics:

• Slack-first. Mention the agent in a thread with a brief and files; finished work posts back to the same thread. You can add notes mid-job and they reach the work in progress.
• A computer per thread. Each thread gets its own Linux sandbox with Chrome, FFmpeg, HyperFrames, D2, and your fonts. Everything it makes is code in a project folder (a slide is HTML, a film is an animation timeline), so changes are edits + re-renders, not restarts. API keys never enter the sandbox.
• Skills + design wiki. A small always-on prompt reads a router skill that picks the right workflow from 35 skills (resized ad, launch film, etc.). The wiki holds craft knowledge (type, colour, layout, charts); your brand pack holds the facts. Skills load only when needed.
• External tools. Video is built in HyperFrames (film as a web page on a timeline); Paper is a shared canvas for editing storyboards/layouts. Image, voice, and music models run as tools outside the sandbox. MCP servers (Notion, Linear, GitHub, Figma) connect through MDA with each person signed in as themselves.
• Async subagents. For big jobs, the main agent plans, splits work, and runs subagents in the background on the same sandbox. Films go storyboard → animatic → production, with code-based review at each stage.
• Memory. Rules like "never use orange on LinkedIn" are saved in that turn. Two layers: team memory (shared) and personal memory (per person).
• Self-improvement. After each job, learn_from_job writes notes on what worked against the skill used. Later jobs read and rate those notes; weak ones get dropped.

Why it doesn't look like AI

• It renders and looks at its work before posting anything.
• Your brand is code — layouts only use your tokens: colours, fonts, spacing.
• It checks what a machine can count on every render: colours, fonts, contrast, sizes, chart math. Taste stays with your designers.

The README shows a side-by-side: the same prompt (a hiring chart) given to a local coding agent with a brand skill vs. Content Studio — the former produces a broken logo lockup, generic font, no axis, off-brand bars; the latter produces a clean lockup, brand typeface, axis with gridlines, brand-blue bars.

Getting started

Deploy to Slack (recommended path):

curl -fsSL https://raw.githubusercontent.com/langchain-ai/design-agent/main/install.sh | bash
cd design-agent
uv run design-agent config set LANGSMITH_API_KEY=lsv2_… ANTHROPIC_API_KEY=sk-ant-…
uv run design-agent sandbox publish   # once per workspace
uv run mda deploy

You need a LangSmith account (Managed Deep Agents is in public beta on LangSmith Cloud) and a model key. The first deploy sets up the Slack app; authorize it, then mention the agent in a channel.

Or use a coding agent: open the repo in Claude Code, Codex, or Cursor and say things like "Deploy it to our Slack," "Build our brand pack from our website," or "Teach it to make our weekly newsletter header." AGENTS.md routes each request to a step-by-step skill.

Try locally (no API keys): needs Docker, runs the real agent with a scripted model:

uv run design-agent sandbox build
uv run design-agent demo

This leaves a launch card in three sizes and a 4-second teaser in workspace/out/demo/. With a model key in .env, you can ask for real work via uv run design-agent ask "…".

Cost

• The code is free (Apache 2.0).
• You pay your model provider: at LangChain, the median request costs ~50 cents in model spend; long films and decks cost more.
• Managed Deep Agents hosting is paid — it runs the agent, sandboxes, Slack app, and schedules you'd otherwise build yourself.

Customization

Want	Add
Your brand	workspace/brand/ (a neutral sample brand ships by default)
Generated images	OPENAI_API_KEY
Voice, music, sound effects	ELEVENLABS_API_KEY
The Paper canvas	PAPER_MODE=local with Paper Desktop, or bridged when deployed
Web search, your docs, other tools	MCP servers in config/mcp.toml

Licensed fonts go in private-fonts/ (git-ignored).

Models

Claude Opus 5.5 by default. OpenAI and Google models, any OpenAI-compatible endpoint, and the LangSmith Gateway also work.

Self-hosting

Yes — it's Apache 2.0. Self-hosting runs the same agent with Docker, an HTTP API, and your own Slack app (see docs/self-hosting.md).

Notes

• Two names: "Content Studio" is what LangChain calls the agent (and its Slack app's default name); the repo, package, and command are design-agent.
• Does it replace a designer? No. It takes the repetitive requests so designers focus on work only they can do; their judgment lives on in its skills and checks.
• Slack not required: you can call the deployment's API, open it in LangSmith Studio, or use the terminal (design-agent ask). Long background jobs (films, parallel looks) report back in Slack; over the API, keep to requests that finish in one turn.
• Security: the sandbox never holds a credential and has no network by default; host tools do fetching, generating, and delivering, dropping results in as files.

Built with

Deep Agents, Managed Deep Agents, HyperFrames, Paper, LangSmith, Chrome Headless Shell, FFmpeg, D2, Apache ECharts, sharp.