Meet Juno — the teammate who's really good with data
Juno isn't a chatbot taped to a dashboard, and it isn't a “feature.” It's a teammate inside PrysmOS with real tools — it writes scripts, edits spreadsheets, publishes endpoints, and always asks before it touches anything it shouldn't.
prysm.spreadsheets.writeprysm.scripts.callprysm.endpoints.publishprysm.contracts.checkask_user
Not a chatbot. Not a copilot. A coworker.
Most AI tools stop at advice. Juno picks up the tools, does the work, and checks in when the decision is yours to make.
Describes the formula you could write, then wishes you luck.
Writes it, recalcs the sheet live, and shows you the diff.
Explains, at length, how an API endpoint works.
Publishes yours as a real endpoint and hands you the URL.
Guesses confidently when your request is fuzzy.
Asks a quick multiple-choice question, then gets it right.
One teammate, ~0 tools
Juno doesn't describe work — it does it, with the same tools you'd use. Every call is a real tool invocation you can inspect, and every action is scoped to your role's permissions.
Spreadsheets
Edits cells, writes real formulas, applies formatting, recalcs live.
Scripts
Creates, edits, runs, and tests JS/TS/SQL — envs, schedules, the whole SDK.
Endpoints
Turns a script into a real HTTP endpoint, docs included.
Contracts
Schema and freshness rules — checked against reality, not just suggested.
Graphs & dashboards
Charts and dashboards from a plain-English sentence.
Docs & doc-sites
Writes documentation that lives next to the data.
Files & secrets
Reads and writes files; uses secrets without the value ever leaving the platform.
Investigations
Multi-step digs into “why did this number move?” across connections.
Watch it work — and watch it ask first.
This is a real Juno conversation shape: a plain-English ask, a chain of tool calls, and a hard stop the moment something destructive comes up.
The tool calls
Each line is a real tool call — prysm.scripts.list, prysm.spreadsheets.read — with real results, not a paraphrase of one.
The pause
When Juno reaches a destructive step — here, deleting a script — everything stops until a human says go.
Your call
Hit Approve or Deny right in the demo. Juno adapts either way and finishes the job around your decision.
Tip: try denying the delete. Juno doesn't sulk — it just does the rest of the job.
Juno never touches anything destructive without asking.
Deletes, script runs, contract changes — they always pause for a human. Every plan, every setting, every time. There is no “just let it run” switch, and when a decision is genuinely yours, Juno asks instead of guessing.
Destructive step → hard stop
Juno wants to run purge-stale-rows.ts — deletes 1,240 rows from inventory-q4.grid
Your call to make → quick question
Which quarter should the forecast start from?
Open a sheet, say “fix this” — done.
Juno sees the resource you have open — the spreadsheet, the script, the contract. No pasting screenshots, no re-explaining the schema, no 'which file did you mean?' Context comes free.
- Aware of the open resource. “Fix this” on a sheet means that sheet — cells, formulas, gaps and all.
- Aware of your workspace. Connections, scripts, contracts — Juno suggests the fix that uses what you already have in PrysmOS.
- Proactive, not pushy. It flags what it notices and waits. You decide what happens next.
You're in inventory-q4.grid — I found 38 rows missing reorder points. I can fill them from the Suppliers connection.
Fast by default. Deep when it matters.
Juno routes every request to the right tools and the right model. Standard handles the daily hundred little asks; thinking mode is for the questions that deserve a longer think.
Standard
default mode
The quick, competent colleague who answers before your coffee cools. Great for the hundred small things that eat a Tuesday.
- Everyday asks: rename a column, explain a formula, chart this range
- Answers in seconds, light on your token budget
- The default — you never have to think about it
Thinking
reasoning mode
For “figure out why churn moved” and “refactor the whole import pipeline.” Juno plans, chains tools, and checks in along the way.
- Multi-step investigations and big refactors
- Juno thinks longer and chains more tools together
- Same rules — destructive steps still wait for you
Juno works while you sleep.
Schedule Juno on a Trigger with three simple dials — a plain-English instruction, a tool allowlist, and a hard call budget. You wake up to a summary, not a surprise.
The instruction
Every weekday at 6am — refresh the exec dashboard, then flag any contract that fails.
The tool allowlist
prysm.graphs.refresh · prysm.contracts.check — nothing destructive is even on the list.
The call budget
40 tool calls per run, max. Hit the cap and Juno stops, writes up what it did, and waits.
Runs are logged like any Juno session — tool calls, approvals skipped, and a summary waiting in your inbox.
Morning run finished — 12 of 40 tool calls used.
orders is failing — fixing it needs your approval.ReviewA generous allowance, not a meter to watch
Juno runs on tokens, and every seat gets a daily and weekly allowance sized to its plan. Here's the whole story — it's shorter than you think.
One seat's week
resets daily & weeklyA typical seat spends well under its allowance — most days look like Tuesday, not a cliff. Unattended runs spend from the same budget, and their call caps stop them before they get ideas.
What a token buys
Every ask, tool call, and answer spends a few. A quick Standard-mode question is pocket change; a deep investigation spends more because it does more.
Warned, never surprised
Juno tells you as you approach the cap — and if a seat hits it, it waits for the reset or an admin bump instead of silently dying mid-task.
Rails, not a meter
Budgets are per seat, daily and weekly, sized to your plan — with tool-call caps on top. They exist to catch runaway loops, not to ration normal work.
What would you ask Juno?
Plain English is the whole interface. If you can say it — or grumble it — Juno can probably do it, or ask you the one question it needs first.
One sentence in, real work out
Every Juno answer comes with receipts — the actual tool calls it made. Here's what an ordinary ask looks like end to end.
You ask
“Fix this — the import sheet is a mess.”
Found the problem: three broken lookups and a column of dupes. I fixed the formulas and flagged 1,240 duplicate rows — deleting them needs your approval.
You ask
“Why did revenue dip last Tuesday?”
Traced it to the orders feed — it stalled for six hours Tuesday morning. The freshness contract didn't catch it because the threshold is 24h. Want me to tighten it?
You ask
“Turn this spreadsheet into an endpoint.”
Done — wrote a script that wraps the sheet's logic, ran its tests, and published it as an endpoint with docs. The URL is ready to share.
The questions everyone asks
Everywhere you work in PrysmOS. There's a dedicated Juno app for longer tasks, a pop-out panel that follows you around the workspace, and it's embedded inside the script IDE and Investigate — so help is always one keystroke away.
Give Juno something to do
Hand it the task you've been putting off — the messy sheet, the undocumented pipeline, the dashboard nobody owns. It'll do the work, and it'll ask before anything important.