Data analysis
Blake runs real Python on your numbers — pandas, numpy and matplotlib in an isolated sandbox with no internet and no secrets. Charts come back as image cards, files as private downloads, and a failed run is refunded.
Bu sayfa senin dilinizde henüz mevcut değil — İngilizce sürümü gösteriyor.
Most AI assistants do arithmetic the way you'd do it in your head at 2 a.m. — plausibly, and sometimes wrong. Blake, your Data Analyst, doesn't. Give him a table and ask for the numbers and he writes real Python, executes it in an isolated sandbox, and reports what actually came back. If the code throws, he reads the traceback, fixes it, and runs it again.
You get the answer, the chart, and the file. Not a paragraph of confident-sounding estimates.
Who can run code
Blake and Tyron are the only agents who can execute Python. Blake uses it for analysis; Tyron uses it for pixel-exact image work. The other eight agents cannot run code at all — they can still ask Blake, and every agent can produce a spreadsheet without the sandbox. That boundary is enforced at runtime, not by a prompt.
What you can do
- Get real arithmetic. Sums, averages, percentiles, growth rates, segment breakdowns — computed in pandas and numpy, not estimated.
- Get a real chart. Blake renders a matplotlib PNG and it appears as an image card in the chat.
- Get a downloadable file. CSV, XLSX, PDF, a Python script — anything the run produces comes back as a card you click to download.
- Get working code. Ask for a script, an algorithm or a data transform and Blake writes it, runs it to prove it works, and ships you the final file plus whatever it produced.
- Analyse a file you upload. Attach a PDF, DOCX, XLSX or CSV and Blake reads the extracted text and feeds it into the computation.
- Read your revenue. Connect Stripe or Shopify and ask how the month is going — read-only, by currency, over a window of up to 90 days.
Ask him something
Here are last quarter's numbers by region. Compute the growth rate per region, tell me which one is dragging the average down, and give me a bar chart.
Take the attached CSV, deduplicate by email, bucket the customers by lifetime value into quartiles, and hand me back an Excel with one tab per quartile plus a summary tab with the totals.
Write me a Python script that reads a CSV of invoices and flags any line where the VAT doesn't match the rate for the country. Run it on this sample so I can see it works, then give me the file.
How a computation actually runs
- You ask. Give Blake the data — paste a table, attach a file, or point him at your connected store. He'll say in one line what he's about to do.
- He announces the step. A "Calcul" step appears in the run timeline before the code runs, so you can see the computation is happening rather than staring at a spinner.
- A fresh sandbox spins up. An isolated micro-VM with no network and no environment variables. Your data goes in as JSON, the code goes in as text, and input files come only from Unyo-hosted URLs. Nothing else gets in.
- The code runs. Up to 60 seconds by default, 90 at the most.
- If it throws, he fixes it. The traceback comes back to Blake with the failing line. He reads it, corrects the code, and calls the sandbox again.
- The sandbox is destroyed. Not paused, not snapshotted — killed, every time, including when the run fails.
- You get cards. Charts render as images. Everything else — spreadsheets, PDFs, code files — lands in a private bucket only you can read, as a card you click to download.
The sandbox: what it can't do, on purpose
The interesting part of a code sandbox isn't what it runs. It's what it's structurally unable to reach.
| Guarantee | How it's enforced |
|---|---|
No internet. The code Blake writes cannot make a single outbound request, cannot pip install, cannot phone home. | Network is disabled at sandbox creation — not filtered, disabled. |
| No secrets. No API key, token or credential of yours exists inside the VM. | The environment allowlist is empty, so no host variable ever enters. |
| Secret-shaped input is rejected before it's sent. | A 20-pattern denylist scans the code and the data payload. A match fails the call — the payload is never forwarded. |
| No arbitrary file fetching. | Input files must be Unyo-hosted URLs. Anything else is refused before the sandbox exists. |
| Nothing survives the run. | The sandbox is killed in a finally block, with a second kill as backup if the handle breaks. A paused snapshot would persist — so we never pause one. |
Why we kill it instead of pausing it
Pausing a sandbox is faster and cheaper. It also means a snapshot of your data sits on a subprocessor's disk indefinitely — which is exactly the thing GDPR's right to erasure exists to prevent. We take the slower option. Every run gets a clean VM and every VM dies with the run.
Charts
Ask for a chart and Blake saves the PNG inside the sandbox and lists it as an output. It comes back as an image card in the chat.
Chart images are kept for 7 days
Chart PNGs live in a temporary bucket and are cleaned up after 7 days — an image card in an old conversation will stop rendering. Downloadable files don't expire. If a chart matters, download it, or ask Blake to also hand you the underlying numbers as a CSV or Excel — those persist.
CODER MODE
Say "write me a script", "code me an algorithm", "build me a data transform" — and Blake switches into CODER MODE.
The contract is simple: he never hands you code he hasn't run.
- He writes it.
- He executes it in the sandbox to prove it works.
- If it errors, he reads the traceback, fixes it, and runs it again — he doesn't stop at the first failure.
- When it runs clean, he ships you the final code file and whatever it produced (
results.txt,data.csv,chart.png) as downloadable cards.
The same directive runs on the interactive path and on scheduled overnight runs — byte-identical, so an automation behaves exactly like the chat.
No internet means no packages
There's no pip install inside the sandbox. Blake works with the Python standard library and the preinstalled scientific stack — pandas, numpy and matplotlib. If a task needs a library that isn't there, he's instructed to implement it in plain Python rather than fail. (We don't publish a pinned library list as a guarantee — the base image is what the sandbox runtime ships.)
Ask Blake for a website and he'll say no
This is deliberate. Blake owns data, scripts and algorithms. Steve owns sites, apps and interfaces. Ask Blake for a landing page and he'll decline in one warm line and point you at Steve rather than half-build you something in a Python file.
Agents staying in their lane isn't a limitation we apologise for — it's the reason the outputs are any good. See Website builder.
Spreadsheets — no sandbox required
You don't need Blake for a spreadsheet. All ten agents can produce a real multi-tab .xlsx — up to 20 sheets and 10 000 rows per sheet — with no code execution involved at all.
Ask Ashley for "my post performance as an Excel" or Maya for "a downloadable table of these threads" and you get a spreadsheet card. Open it in the side panel to browse the tabs, then download it as Excel, CSV or PDF, save it straight to Google Drive, or open it as a native, editable Google Sheet.
Use Blake's sandbox when the numbers need computing. Use any agent when they just need exporting. Full detail: Spreadsheets.
Revenue analytics — read-only, by construction
Connect a store or a payment processor and Blake can report on it. What he cannot do is touch it.
Stripe
Blake is the only agent with your Stripe connection, and his Stripe tools are read-only by construction: only get_ and list_ verbs exist in the code. There is no charge, no refund, no payout code path to invoke — not disabled, not permission-gated. Absent.
| Ask | What you get |
|---|---|
| "How much did I make this month?" | Gross collected, net, refunded, payment count and average payment — per currency, over a window of up to 90 days. |
| "Show me my recent payments" | Up to 50 recent charges with amount, currency, status and customer email. |
| "How much is in my Stripe?" | Available and pending balance, by currency. |
| "When did I get paid out?" | Recent payouts with amount, status and arrival date. |
Shopify
One Shopify connection lights up three agents, each in its own lane:
- Blake — gross and net sales, order count, average order value and refunds, by currency, up to 90 days back. Plus your catalogue with price range and total inventory.
- Sam — finds any order by number ("where is #1001?") with line items, financial and fulfilment status, customer and tracking numbers. See Shopify.
- Alex — abandoned carts with contents, totals and the real Shopify recovery URL to draft outreach from.
Every Shopify scope we hold is a read_* scope. Blake cannot edit a product, cancel an order or issue a refund, because we never asked for the permission to.
Revenue summaries are samples, not audited totals
A Stripe revenue summary reads up to 100 charges per window; a Shopify shop summary reads up to 250 orders. If your volume exceeds that in the window you asked for, the result is flagged as truncated and Blake will tell you so rather than present a partial figure as a total. These are management-decision numbers, not your books. For accounting, use your provider's own reporting.
What Blake deliberately cannot do
Enforced at the runtime layer, not requested politely in a prompt:
- No inbox. Blake cannot read, draft, send or schedule a single email. Maya is the only agent with your mailbox.
- No publishing. He cannot post, schedule or cancel anything on your social accounts.
- No image generation. That's Tyron's domain.
- No money movement. No mutation verb exists in his Stripe or Shopify tools.
He keeps analytics, web research, the Neural Core, Drive, Calendar, documents and the sandbox. That's the job.
Where your files live
Anything that isn't an image goes into a private storage bucket with owner-only read access. The app downloads it using your own session. No signed URL is ever created and stored — there's no link that could leak, because there is no link.
Downloadable deliverables have no expiry. They're removed when you delete your account, along with everything else. See Your data and deletion.
What it costs
| Action | Credits |
|---|---|
compute.run — one sandbox execution | 25 |
| A failed sandbox run | 0 — refunded automatically |
| Reading your Stripe / Shopify numbers | Free |
| Web search and reading a URL | Free |
A sandbox execution costs 25 credits. And it is refundable on error: if the sandbox run fails, you are not charged for it. An hourly janitor refunds anything left stranded.
Note that CODER MODE deliberately runs the code more than once — write, run, fix, re-run. Each execution is a compute.run. Getting working code usually costs two or three of them, and the ones that failed come back to you.
Full detail: Credits and billing.
Limits worth knowing before you ask
| Limit | Value |
|---|---|
| Data passed to a computation | 4 MB of JSON |
| Input files | 5 files, 8 MB each, 16 MB total |
| Files returned from one run | 3 |
| Run time | 60 s default, 90 s maximum |
| Code size | 64 KB |
| Spreadsheet export (any agent) | 20 sheets × 10 000 rows |
Work with an extract, not the whole database
"Analyse my entire database" isn't a supported story — 4 MB of JSON is roughly tens of thousands of rows, not millions. Give Blake the extract that answers the question: the right columns, the right window, aggregated where you can. He'll compute exactly on what you give him, which is the point.
Tips
- Say what you want computed, not what you want said. "Compute the median and the p90, then tell me if the tail is a problem" gets you a better answer than "how are we doing?".
- Ask for the chart and the data. Charts expire after 7 days; the CSV doesn't.
- Watch the timeline. The "Calcul" step tells you the code is actually running. If you don't see it, you're getting prose, not arithmetic — say "compute this, don't estimate it".
- Attach the file rather than pasting the table. Uploaded PDFs, DOCX, XLSX and CSV get their text extracted and read properly.
- Blake states his gaps. He's instructed to ground every claim in numbers he actually fetched and to say honestly when data is missing. If he says the store isn't connected, that's the feature working — he's refusing to invent the number.
Troubleshooting
"The chart card in my old conversation is broken." Chart images are cleaned up after 7 days. Ask Blake to regenerate it — or next time, download it, or ask for the underlying data as a file too.
"Blake says my Stripe/Shopify connection has expired." Reconnect from Integrations in the sidebar. Blake detects an expired grant, clears the dead connection and tells you — he won't quietly return stale numbers.
"Blake refused to run my code." If your code or your data contains something shaped like an API key, token, private key or credential, the call is rejected before it reaches the sandbox. This is fail-closed and deliberate. Remove the secret and ask again — the sandbox has no internet, so nothing in it needs a key anyway.
"The computation timed out." Runs cap at 90 seconds. Narrow the window, aggregate before you pass the data, or split the work into two questions.
"He gave me the total but no file." Ask explicitly: "give me that as an Excel" or "save the chart". Blake returns files only when the run saves them as outputs.
"He wrote the code but never ran it." Say "run it and show me it works". CODER MODE is his default for scripts, but an explicit ask guarantees it.
Does Blake actually run Python, or is he just describing what Python would do?
He actually runs it. Each computation executes as real Python — pandas, numpy, matplotlib — inside an isolated micro-VM, and the numbers he reports are the numbers the code returned. His toolbox instructs him never to do row-level math in his head when he can compute it. You can see the computation step appear in the run timeline before the result arrives.
Can the sandbox reach my accounts, my inbox, or the internet?
No — and not because we told it not to. Network access is disabled when the sandbox is created, so the code cannot make an outbound request or install a package. The environment variable allowlist is empty, so no credential of yours exists inside the VM. Input files must be Unyo-hosted URLs; anything else is refused. And Blake has no email tools at all — only Maya has your inbox.
What happens to my data after a computation?
The sandbox is destroyed — killed in a finally block after every run, including runs that failed, with a second kill as a backup. We never pause a sandbox, because a paused snapshot would persist on disk and that's exactly the liability the right to erasure exists to prevent. Files you asked for land in a private bucket only your session can read; chart images are cleaned up after 7 days.
Am I charged if the computation fails?
No. A sandbox execution is 25 credits and is marked refundable on error — a failed run is refunded automatically, and an hourly janitor sweeps anything left stranded. This matters in CODER MODE, where Blake deliberately runs code, reads the traceback and runs it again: the attempts that failed come back to you.
Can Blake move money, refund a customer, or edit my store?
No, and not by configuration — by construction. Only read verbs exist in his Stripe tools; there is no charge, refund or payout code path to call. Every Shopify permission we hold is a read permission, so editing a product or cancelling an order isn't something he's blocked from doing — it's something the connection was never granted.
Can the other agents run code too?
Just Tyron — he uses it for deterministic image compositing. The other eight agents cannot execute code at all. They can still hand you a real multi-tab Excel, though: that path uses no sandbox and is open to every agent.
Related
- Spreadsheets — multi-tab Excel from any agent
- File attachments — give an agent a PDF, DOCX or CSV to read
- Web research — search and read the live web, no connection needed
- Shopify · Stripe — read-only by grant, read-only by construction
- Blake — the Data Analyst
- Security and privacy — the full trust picture