Part 2
Automate document work
without writing code
Upstage Studio lets you connect blocks on screen. Learn what four blocks do and you can design most repetitive document work yourself.
What this part covers
The convert → extract → judge sequence from Part 1, this time built on screen.
What kind of tool Studio is
What you can build and how the screen is laid out.
What each of the four blocks does
Parse, Classify, Extract, and Instruct.
How to connect them
Four connection patterns that cover most situations.
How to improve it afterwards
Correcting wrong results is what builds accuracy.
The AI Initiative covers Document Parse usage. That applies in Studio too: the Parse block is covered, while the Extract block adds a per-page charge on top of it.
Classify and Instruct are free while in Beta, but only for now. They become paid once pricing is set.
You also receive welcome credits on sign-up and a number of free runs each billing period, so there is plenty of room to learn. See 2.6 What does it cost for details.
2.1What Upstage Studio is
Upstage Studio is a screen for building and running document automation without coding. You can find it at studio.upstage.ai.
Three terms are enough
| Term | Meaning |
|---|---|
| Agent | One complete automation made of connected blocks. Put a file in, get a result out |
| Block (node) | A single processing step. Blocks run in order |
| Workspace | Where your agents and files live |
The screen has three areas
| Menu | Role | What you do there |
|---|---|---|
| Home | Build and run agents | Upload files, configure blocks, view results |
| Library | Browse ready-made examples | Search by type of work and add to your workspace |
| Monitoring | Check how runs are going | Run counts, processing time, success rate |
The run view has three panels
Left · file list
Your uploaded files. Use the checkboxes to choose which ones to run.
Centre · document preview
The original document. Where each value was taken from is highlighted, so you can check results against the source immediately.
Right · results
One tab per block. Seeing each step separately makes it easy to find where things went wrong.
Build in Home, borrow from Library, watch in Monitoring. Those three are all you need.
2.2The four blocks
Studio has four blocks. They handle converting, sorting, extracting, and judging.
Parse — turn a document into text
The first block in every automation. It converts any format — PDF, image, HWP — into text. This is the Document Parse you met in Part 1.
| Setting | Options | What to choose |
|---|---|---|
| Mode | Auto / Standard / Enhanced | Standard is usually enough. Use Enhanced for complex tables and figures |
| OCR | Auto / Force | Force is recommended — it improves accuracy on scans and photos |
| Language | Auto / manual | Fixing the language improves accuracy if all your documents are in one language |
Turn on Merge Multipage Tables if tables continue across pages, and Chart recognition if numbers inside charts matter.
Classify — sort documents by type
Use this when several kinds of document arrive together — domestic and overseas receipts, contracts and invoices — and each type needs different handling afterwards.
| Mode | When to use it |
|---|---|
| Classify only | Each file contains one type of document. Labels the file without splitting it |
| Classify with Split | One file contains several documents. Splits them, then labels each one |
If you only ever handle one type of document, you can leave this block out.
Extract — pull out only the fields you need
Extracts specific fields such as names, amounts, and dates. The list of fields you define in advance is called a schema.
| Schema item | What to write | Example |
|---|---|---|
| Key name | The name of the field | total_amount |
| Description | What the model should look for, in a sentence | "The final payment amount at the bottom of the receipt" |
| Type | The shape of the value | string / number / boolean |
| Array | Whether the same shape repeats | Tick it for a list of purchased items |
Upload a file first, then press [Auto-generate] to get a draft schema. Reviewing that draft and refining the descriptions saves a lot of setup time.
How specific your descriptions are decides your accuracy. "The final payment amount including tax" finds the value far more reliably than "amount".
Instruct — judge against your criteria
This block gives instructions to the AI using the values extracted earlier. Use it to decide approvals, normalize formats, or summarize content.
| Mode | When to use it |
|---|---|
| Prompt | For free-form text answers. Good for summarizing, tidying, and rewriting |
| Prompt with decisions | To choose one of a fixed set of values. Good when you need a verdict such as approve or reject |
Write @field_name in your prompt and the value from the earlier block is inserted. For example, @total_amount.
Parse converts, Classify sorts, Extract pulls out, Instruct judges. Use only the blocks you need.
2.3How to connect them
Every automation starts with Parse and adds only what it needs. These four patterns cover most work.
| Chain | Use it when | Example |
|---|---|---|
| Parse → Extract | One document type, no judgment needed | Pulling fields from a fixed form into a table |
| Parse → Extract → Instruct | You need a conclusion from the extracted values | Approving or holding a receipt based on its total |
| Parse → Classify → Extract | Mixed types, each needing different fields | Splitting a batch of contracts and invoices, then processing each |
| Parse → Classify → Extract → Instruct | You need sorting, extraction, and judgment | Corporate card reconciliation, expense processing |
How to choose
Do you get more than one type of document?
If so, add Classify. If only one type arrives, you can skip it.
Do you need specific fields?
If so, add Extract. If you only want a summary of the whole document, you can skip it.
Do you need a conclusion or judgment?
If so, add Instruct. If you only need the values tidied up, you can skip it.
Always include Parse, and add the other three only when needed. Fewer blocks are easier to manage.
2.4[Activity] Design your own
Take the task you chose in Part 1 and express it as blocks. Fill in the template, then check it against the list at the end.
A. Blank template
# My automation design
## The documents
- Format (PDF / image / HWP etc.):
- How many at a time:
- More than one document type (yes / no):
## Block chain
Parse → [ ] → [ ] → [ ]
## What each block does
- Parse: convert the document to text (OCR: Force)
- Block 1:
- Block 2:
## Extract schema (fields to pull out)
- Key: / Description: / Type:
- Key: / Description: / Type:
- Key: / Description: / Type:
## Draft Instruct prompt
(What to judge from the extracted values, as numbers and conditions)
## What happens with the result
- If the verdict is A, next action:
- If the verdict is B, next action:B. A worked example — checking expense receipts
# My automation design
## The documents
- Format: photos of receipts (JPG), occasionally PDF
- How many at a time: 10–30
- More than one document type: yes (domestic / overseas receipts)
## Block chain
Parse → Classify → Extract → Instruct
## What each block does
- Parse: convert receipt photos to text (OCR: Force)
- Classify: split into domestic and overseas receipts
- Extract: pull out merchant, date, total, and line items
- Instruct: decide approval based on the total
## Extract schema
- Key: store_name / Description: merchant name at the top of the receipt / Type: string
- Key: issued_date / Description: the date printed on the receipt / Type: string
- Key: total_amount / Description: final payment amount including tax / Type: number
- Key: items / Description: item names and their amounts (multiple) / Type: array
## Draft Instruct prompt
If @total_amount is over 100,000, start with "HOLD"; otherwise start with "APPROVE".
On the next line, give the reason in one sentence.
If @store_name or @issued_date is empty, mark it as "NEEDS CHECK".
## What happens with the result
- APPROVE: attach to the approval document and submit
- HOLD: ask the requester for supporting evidenceC. Checklist
- Classify is included if you handle more than one document type.
- Each Extract description says specifically what to look for.
- Every field needed for the judgment is in the schema.
- The Instruct criteria are numbers and conditions, not "review it".
- The output format you want is stated in the prompt.
- You decided what happens after each verdict.
If nothing is unticked, go ahead and build it in Studio. If one or two are, fix just those.
There is no need to get it perfect first. Building it, running it, and adjusting from the results is much faster.
2.5Refining what you built
First versions are rarely perfect. Accuracy comes from reviewing results and correcting them.
Edits become new versions
When you change a setting it is marked as a draft. Running it in that state saves the configuration as a proper version — there is no separate save button to look for.
Earlier versions remain available, so if a change makes things worse you can go back and compare.
Correcting wrong values teaches it
Run 20–30 items first
Rather than perfecting the schema up front, run a batch and see which values go wrong most often.
Review the results
Look for empty values, values picked from the wrong place, and formats that vary.
Correct and save them
You can edit values directly in the results table. As corrections accumulate, Studio proposes schema improvements.
Review the proposal and apply it
Check the suggestion before applying. Make sure a description has not become so narrow that it misses other cases.
Keeping an eye on it
The monitoring view shows run counts, processing time, and success rate, broken down per block — so you can see which step is slow or failing.
Sharing with your team
Agents can be shared by link, and anyone with the link can view them without signing in.
Anyone with the link can see it. Make sure no results from runs containing personal or sensitive information are still visible. See Part 6 · Using It Safely for more.
Correcting wrong results is what creates accuracy. Building and adjusting beats trying to get it perfect first.
2.6What does it cost
Blocks in Studio are processed differently, so costs are counted per block. Knowing this up front lets you experiment freely.
| Block | AI Initiative | List price | How it is counted |
|---|---|---|---|
| Parse | Covered | $0.01/page | This is Document Parse usage, so the program covers it. Charged once per page even when several blocks run |
| Classify | Free while in Beta | $0 | A temporary Upstage policy, not a program benefit |
| Extract | Uses credits | $0.03/page | Added on top of Parse ($0.04/page in total) |
| Instruct | Free while in Beta | $0 | Pricing to be announced |
Prices are the published list as of August 2026, excluding tax.
Classify and Instruct are free today, but that is a Beta-period policy. They become paid once pricing is set.
Use them freely while learning and validating a design — but budget for production as though they are paid.
You receive welcome credits on sign-up, plus a number of free runs each billing period. The badge next to the run button shows how many you have left.
That is more than enough for learning and validating a design. Failed runs are not billed, so retry without worry.
Building economically
Run Parse on its own first
Parse is covered, so start by confirming the document reads correctly. If the text is empty, running the later blocks will not help.
Use fewer blocks
The block that carries a charge today is Extract — check whether you really need those fields. Skip Classify if you only handle one document type, and Instruct if you do not need a verdict.
Tune on a few items first
Getting the settings right on two or three items before running the whole batch saves a great deal of trial and error.
Failed runs are not billed
Requests that end in an error cost nothing, so feel free to retry when a result comes back empty.
The AI Initiative also covers the Solar Pro 2, Pro 3, and Pro 4 APIs. So if you build it in code as in Part 3, both Document Parse and Solar fall within the program.
A good approach is to design and validate quickly in Studio, then move to code once you are running things repeatedly. The schema and prompts you worked out in Studio carry over directly.
In Studio the program covers Parse only. Classify and Instruct are free while in Beta, and Extract carries a per-page charge. Build it in code and Solar is covered as well.
Part 2 key takeaways
- Studio is a screen for building document automation without code.
- There are four blocks: Parse converts, Classify sorts, Extract pulls out, Instruct judges.
- Always include Parse and add the rest only when needed — fewer blocks are lighter to run and cheaper.
- Extract gets more accurate the more specific your descriptions are.
- In Studio the program covers Parse only. Extract is charged per page; Classify and Instruct are free only while in Beta. In code, Solar is covered too.
Where to go next
You can now design a complete automation. For finer control, take a look at building it in code.