> ## Documentation Index
> Fetch the complete documentation index at: https://docs.splox.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Your first real result
> Ask for a job that ends in a file, then check the file three ways: from another chat, off the machine, and with your own eyes
The first thing worth asking for is something that ends in a **file**, because a
file is what you can go and check. That is the whole difference between an agent
with a computer and a chat window: what it made is still there when the
conversation is over.
Fifteen minutes, no code, and three ways of checking the same result.
Open a new chat and say what you want, in your own words, naming where the file
should go:
```text theme={null}
Work out the repayment schedule for a $10,000 loan at 7% a year over 12 months.
Write the month-by-month table to /home/daytona/reports/loan.csv, and tell me the
monthly payment and the total interest.
```
Two things in that sentence are deliberate. It names an **absolute path**, so
there is no doubt where the file lands — `/home/daytona` is the agent's home, and
the file tools do not expand `~`. And it asks for a file *and* an answer, so you
have two things to check against each other.
While it works you get a collapsed chip — `Ran /home/daytona/reports/loa… (+1 more)`.
Click it and the turn opens up.
There is no loan-calculator tool on this machine, and none was needed. The agent
wrote a program and ran it in its shell, then read the file back to check itself.
Two tool calls, then the answer:
```text theme={null}
Monthly payment: $865.27 — Total interest: $383.22 (total paid $10,383.22)
```
This is what went into the first tool call. You never write this; it is here so
you can see what "it wrote a program" means.
```python theme={null}
from decimal import Decimal, getcontext
import csv
getcontext().prec = 28
P = Decimal("10000") # principal
annual = Decimal("0.07") # annual rate
n = 12
r = annual / 12
# standard amortizing payment
factor = (1 + r) ** n
payment = (P * r * factor) / (factor - 1)
payment_q = payment.quantize(Decimal("0.01"))
rows = []
balance = P
for m in range(1, n + 1):
interest = (balance * r).quantize(Decimal("0.01"))
principal = payment_q - interest
# last payment: clear the remaining balance exactly
if m == n:
principal = balance
balance = balance - principal
...
```
Worth noticing in the reasoning above it: a fixed payment leaves two cents on the
table, so it made the last payment \$865.25 and the balance lands on zero.
Start a **new chat** — not another message in the old one — and ask:
```text theme={null}
Read /home/daytona/reports/loan.csv and tell me the total interest across the
twelve months.
```
It reads the file and answers `$383.22`, adding up the twelve numbers it found
there:
```text theme={null}
The total interest across the twelve months is $383.22.
That's the sum of the interest column (58.33 + 53.63 + 48.89 + 44.13 + 39.34 +
34.52 + 29.68 + 24.80 + 19.90 + 14.97 + 10.01 + 5.02).
```
The second conversation knows nothing about the first one. The **machine** is
what they share, and that is the point of this check: the file outlived the chat
that made it.
Still in that second chat:
```text theme={null}
Give me a download link for that CSV.
```
Behind the chip is one tool call and what it returned:
```json theme={null}
{"url": "https://41999-aonmiuynlxeublg6.splox.app/loan.csv", "filename": "loan.csv", "expires_in_seconds": 3600}
```
The link is served from the machine and lasts an hour (`expires_in_seconds: 3600`).
Opened anywhere — no session, no key — it is the file itself, all 422 bytes of it:
```text theme={null}
month,payment,principal,interest,remaining_balance
1,865.27,806.94,58.33,9193.06
2,865.27,811.64,53.63,8381.42
```
The third check needs no agent at all. Open the inspector on the right of the
chat: under **Sandbox** are **Open in VS Code** and an **SSH** command for this
machine, good for an hour.
```bash theme={null}
ssh -p 2222 c9f1a2b7e40d3856@sandbox.splox.io
```
That is an editor and a shell on the same disk the agent has been writing to —
`/home/daytona/reports/loan.csv` is there, as an ordinary file. Reading it that
way is inspection, not work: you are checking what your agent did, not taking
over from it. **Revoke access** in the same panel ends both at once. See
[The chat](/app/chat).
## Undoing it
Two different things, and it is worth knowing which is which:
* **Delete the chat** (chat menu → *Delete*) and the conversation is gone.
`/home/daytona/reports/loan.csv` is not: deleting a chat never touches the
machine.
* **Delete the file** by asking — `Delete /home/daytona/reports/loan.csv` — and it
is gone from the disk while the conversation stays.
* **Stop the machine** and neither is lost. The machine's own settings screen
says it plainly: *a stopped machine keeps its files and comes back where it left
off.*
## What you just saw
**The agent writes code instead of filling in a form.** No tool was installed for
this job. The model's tool is a shell, and the answer came from a program it
wrote in it. [Tools](/reference/tools) explains why the platform is built that way.
**Files outlive conversations.** `/home/daytona/reports/loan.csv` belongs to the
[machine](/concepts/machine), not the chat — that is what made the second and
third checks possible.
**Every turn is inspectable.** The reasoning, each call, its arguments, its result
and the bill are all kept against the [run](/concepts/run), and the footer under
the answer says which model ran it and how long it took.
## Next
Something your agent cannot do yet: ask for it, and watch it write the tool and publish a version.
The same kind of run over HTTP: create it, stream its events, read its outputs.