Streamlit owns browser dashboards authored as code; scene targets live agent-operated terminal UIs, and should learn from its agent-skills packaging.
Complement it: it does a neighbouring job; interoperate.
the steelman: the best honest case for it
Streamlit made the dashboard a twenty-line Python script, and that is exactly the shape an LLM writes best. The rerun model means there is no callback graph to get wrong: the UI is a pure function of the script and session state, which is why generated apps usually work on the first try. It is the default target for 'make me a dashboard' across ChatGPT, Claude and Snowflake's own Cortex Code, and Streamlit now ships agent skills inside the package so coding agents learn current APIs. Fragments with run_every give live dashboards without websockets plumbing, AppTest gives headless verification, and Snowflake's backing means a two-week release train and enterprise hosting. Nearly 5M weekly downloads say the model won.
scores
UI as data
3 scene 5
Declarative Python; the wire form is a protobuf element tree, not an authored value.
Agent can drive it
2 scene 5
Official agent skills for code generation plus AppTest; no live-control protocol.
Agent can see it
3 scene 5
Structured via AppTest; screenshots for a live browser session.
Small, targeted edits
2 scene 5
Hot reload on script edit; coarse.
Time travel
0 scene 0
Live data rate
2 scene 5
run_every polling reruns; seconds-scale.
Terminal native
0 scene 5
Pixel graphics
4 scene 4
Teaching
2 scene 3
Maturity
5 scene 1
Openness
4 scene 4
Apache-2.0 under Snowflake control.
Streamlit scene now scene planned
how agents use it
How
Code generation is the main path: Streamlit bundles 'developing-with-streamlit' agent skills (17 sub-skills, app and theme templates) in the pip package; Snowflake Cortex Code generates Streamlit-in-Snowflake apps. Community MCP wrappers exist (e.g. dkedar7/streamlit-mcp, 2 stars) but nothing official. AppTest lets an agent run and inspect an app headlessly.
Wiring it in
Low for generation (write a .py, `streamlit run`); higher for driving a live session (browser automation or AppTest).
Seeing the result
AppTest exposes elements and values; live sessions need screenshots/DOM.
Small edits
Edit the script and the app hot-reloads; no id-addressed patches to a running UI.
History
None for the UI; reruns are not recorded.
In short
The most LLM-friendly code target for dashboards, with official agent skills, but agents author code rather than operate a live UI.
architecture
An app is a Python script; every interaction reruns it top to bottom, and the server streams a delta-encoded element tree (protobuf over WebSocket) to a React front end that reconciles it. State lives in st.session_state and caches (st.cache_data/resource). Fragments (@st.fragment) rerun only part of the page, on widget interaction or on a timer via run_every, which is the mechanism for live dashboards. Since 1.57 the server is Starlette/Uvicorn, exposed programmatically via st.App. Custom components extend the front end.
Rerun model: UI is a function of the script plus session state; simple to reason about, costly for high-frequency updates.
st.fragment(run_every=...) gives timer-driven partial reruns for polling dashboards.
AppTest runs an app headlessly and exposes the element tree and widget values for assertions.
Ships agent skills in the pip package (1.57+), `streamlit skills` installs them for Claude Code (1.64 fix).
performance
No published update-rate or throughput numbers. Live updates are polling reruns (run_every), suited to seconds-scale refresh, not streaming ticks.
adoption and upkeep
Adoption
The de facto Python data-app framework; homepage claims 'over 90% of Fortune 50' and ~19.4M monthly downloads. The usual target when an LLM is asked for a quick dashboard.
Used by: Snowflake (Streamlit in Snowflake), Cortex Code CLI users
Maintainability
Very active, corporate-funded, fast release train.
Full or fragment reruns make high-frequency streaming expensive; no published update-rate numbers.
Agents generate code; there is no protocol to patch or operate a running app.
Browser-only; no terminal renderer.
Corporate control by Snowflake; hosted features steer toward Snowflake.
No history or replay of UI state.
and thc-scene
Overlap
Agent-built dashboards bound to data, refreshed on a timer, with a pure 'state to view' model.
What scene would be reinventing
The 'dashboard from a few declarative lines' experience and its huge catalog of chart/table/metric widgets; Streamlit is what an agent reaches for by default and it already works.
The gap it leaves
A long-lived UI an agent patches by id at high rate, reads back as structured state and screen text, in the terminal; Streamlit regenerates code and reruns scripts in a browser.
What to borrow
Ship agent skills inside the package and offer to install them on first error (Streamlit 1.59/1.62).
run_every-style per-component refresh intervals as a first-class component property.
AppTest-style headless harness: run, set widget values, read the element tree.