Streamlit for agents

The shortest path from a request to a verified app

Coding agents build Streamlit apps in plain Python, guided by expert skills that ship with every release. They verify the running app without a browser. And every finished app is a tool that other agents can use over MCP, with the same logic and access rules as the people in the browser.
Your coding agentstreamlit skills
  • YouBuild a Streamlit churn dashboard over the customers table, with plan and region filters.
  • Loaded Streamlit's skill for the installed version
  • Wrote app.py and churn.py
  • Ran the app, set Plan to “Pro”, and read 3 metrics and 1 chart back as data
  • Done. The dashboard has plan and region filters, churn and retention metrics, and a monthly trend. I checked the numbers in the running app and added a test, so CI catches regressions.

Expert agent skills, built in

Written by the Streamlit team

Every Streamlit release ships with optimized, battle-tested skills for coding agents, matched to that version.
  • Always current

    The skills match the installed version, so agents write for the version you actually run.
  • Expert by default

    They cover building, styling, speeding up, testing, and deploying apps, from layouts and theming to caching, editable tables, chat interfaces, custom components, and Snowflake. They also include ready-made dashboard templates.
  • One command

    streamlit skills installs them into your project for Claude Code and for agents that read the shared .agents skills folder. When an app hits an error, Streamlit itself suggests installing them.
  • Ask for Streamlit

    Mention Streamlit in your request, or invoke the skill directly with /developing-with-streamlit, and your agent loads the skills for the job.
  • Better apps with every release

    When the skills improve, every app that agents build or change afterward improves too.
A custom stack is assembled from many libraries, each documented separately, if at all. No single expert guide covers the whole app, so the result differs from one run to the next.
Terminal
# In your project, with the latest Streamlit
$ pip install --upgrade streamlit
$ streamlit skills
# Adds the skills for your Streamlit version
# to .agents/skills (and .claude/skills)

# Or once, for every project on this machine
$ streamlit skills --global

# To be sure your agent applies them
> /developing-with-streamlit Build a churn
> dashboard with plan and region filters.

Agent-native

Built for the whole agent lifecycle

Agents no longer just write the code. They take part in every stage of an app's life, and Streamlit is built for each one.
  • 01 / Build

    A forecast app from a request

    Models already know Streamlit's compact API, and the built-in skills keep agents on current best practices, in a fraction of the code of a custom stack.
  • 02 / Verify

    The numbers changed after an edit

    Agents drive the running app without a browser, read the numbers back as data, and leave tests behind for CI.
  • 03 / Run

    Where your data lives

    One Python process, no build step, and built-in authentication. Run it on Snowflake, in your own cloud, or on Community Cloud.
  • 04 / Use

    A question from Claude or ChatGPT

    Every app is also an MCP tool, limited to exactly what it shows its users. Existing apps need no code changes.
  • 05 / Maintain

    A business rule changes

    Agents update the app in Python that's easy to review. Upgrades improve every app at once, and breaking changes are extremely rare.

Agents as users

Write your business logic once. People get an app. Agents get a tool.

One app packages the queries, the calculations, the definitions, and the rules about who may see what. People use it in the browser. Agents use it as a tool, with the same numbers and the same access rules.
  • Same numbers, same access rules

    An agent gets exactly what the app shows its users, through the same logic and access rules as a person in the browser. No more authority, and no more data.
  • Data, not screenshots

    Agents read tables and charts as data, set filters, submit forms, and follow multi-step flows.
  • Fast and cheap to answer

    Agents run through the app's own caches, connections, and partial reruns, so a question often needs no new query and gets the same numbers people see.
  • Nothing new to build

    Existing apps need no code changes, and there's no second API to build, secure, maintain, and optimize.
Your AI assistantchurn app · MCP
  • YouWhich plan had the highest churn last quarter, and is it improving?
  • Set Quarter to “Q3” and read the churn table, 3 rows, as data
  • Set Quarter to “Q2” and read the table again
  • Starter had the highest monthly churn in Q3, at 3.4%, down from 3.9% in Q2. Pro and Enterprise stayed under 1%. These figures come from the churn app, so they match what your team sees in the dashboard.

Why it works

Streamlit apps are already shaped for agents

An agent works in a loop: observe, act, and observe the result. A Streamlit app runs in the same loop: widget state, a script run, and the resulting elements. A typical web app spreads that loop across the DOM, client-side code, and separate APIs.
Streamlit apps are already shaped for agents
What can I do right now?StreamlitThe current widgets, with their labels, help text, options, and boundsA typical custom web appSpread across the DOM, client-side code, validation, and a separate API
When did my action finish?StreamlitEvery run ends with an explicit completion signalA typical custom web appOne click can fan out into several requests, with no shared signal
What did I get back?StreamlitTables, metrics, and chart specs as data, named after the st.* APIA typical custom web appRebuilt from HTML, the accessibility tree, or screenshots
Where is the business logic?StreamlitIn the app people already use and review; an agent's input takes the same path as a clickA typical custom web appUsually duplicated into a second service so agents can call it
Who controls access?StreamlitThe same rules as the browserA typical custom web appA separate API with its own authentication to build and secure

Connect an app

Add a running app to any MCP client

Every running app serves agents over MCP at /_stcore/agent/mcp, and over plain HTTP, with no code changes. Add the app's URL to your agent, and ask your question.
Connect your agent
# Run the app as usual
$ streamlit run app.py

# Claude Code
$ claude mcp add --transport http revenue \
    http://localhost:8501/_stcore/agent/mcp

# Cursor (.cursor/mcp.json) and other MCP clients
{ "mcpServers": { "revenue": {
    "url": "http://localhost:8501/_stcore/agent/mcp" } } }
  • Claude, ChatGPT, Cursor, and more

    Add the app as a remote MCP server in Claude, Claude Code, Cursor, VS Code, or ChatGPT as a custom connector, or in any client that speaks MCP over HTTP.
  • Plain HTTP, too

    Agent platforms without MCP can call the app's HTTP interface, which describes itself with an OpenAPI document.
  • In your control

    Requests from web pages are refused unless their origin is on the app's allow-list, and one setting turns agent access off for an app.

Frequently asked questions

Get started

Set up your coding agent

Install Streamlit, set up the skills, and describe the app you need. Then connect the running app to the agents that will use it.
Terminal
$ pip install streamlit
$ streamlit skills

> /developing-with-streamlit Build a forecast
> app with a price lever, over the sales
> table in Snowflake.

$ streamlit run app.py