> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orisu.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Feed
> Run agents across a whole product catalog — import, generate, review, and export from one grid.
The Feed is a workspace-scoped grid where each row is a product and each column is either data, an agent run, or a run's output. Import a catalog, run creative agents across every row in bulk, review the results, and export a hosted feed file that Meta and TikTok pull automatically.
## Column types
| Kind | What it does |
| ---------- | --------------------------------------------------------------------------------------------------------------------- |
| **Data** | Product fields you type or import — text, price, select, image URL, date, and more. |
| **Run** | Mounts a published agent. Each cell runs the agent once for its row, with inputs bound from your data and AI columns. |
| **Output** | Shows one output of a run column (an image, a headline) — created with one click from the review drawer. |
Run columns pin the agent's deployed version, so a feed keeps producing consistent results even while you keep editing the agent in the studio.
You aren't limited to your own agents. The agent picker also lists **Explore apps** — community apps published in Orisu, shown with real outputs they've produced. Picking one saves a private copy to your workspace behind the scenes and mounts it like any other agent: runs bill to your credits, and the copy stays as it was when you added it, so a later change by the author never alters what your feed produces. Adding the same app to more columns or feeds reuses the same copy. If the author later ships an update, the column's settings show an update button — your copy changes only when you click it.
Adding an agent column walks through three steps:
1. **Connect inputs** — Orisu pre-matches the app's inputs to your columns by name and type; adjust anything it guessed wrong.
2. **Test on a row** — run the app once with a real row's values and see the output in the dialog before anything runs in bulk. One real run, billed like a single cell. Optional, but it catches a wrong binding before it multiplies.
3. **Name & outputs** — name the column, add per-row instructions, and pick which of the agent's outputs appear as their own read-only columns.
### Configuring a data column
Open **Edit column** from a header's menu (or double-click the header) to set:
* **Name** and a **description** (shown as a tooltip on hover over the header)
* **Default value** — pre-fills new rows; date columns can instead default to **creation time**
* **Required** — an advisory indicator on the header; it doesn't block saving a row
* Per-type options — decimal precision and percent formatting for numbers, an ISO-4217 currency for price, minimum width/height for images, include-time-of-day for dates
Select columns manage their **options** here too: give each one a name and a color, and toggle **Allow multiple values** to turn the column into a multi-select.
### Changing a column's type
The same **Edit column** popover has a **Type** select. Pick a new type and existing values are converted where possible — numbers are parsed out of text, dates recognized, and converting to select builds the options list automatically from the values already in the column. Values that can't convert are cleared; after saving, a toast reports how many converted and how many were cleared.
## Working with rows
* **Import** — upload a CSV or connect Shopify. Orisu proposes a field mapping you confirm once; re-imports reuse it and only update rows that actually changed. New columns get a type inferred from the values in your file (number, price, date, URL, and so on), with a per-column override right on the mapping screen.
* **Normalize with AI** — instead of hand-tuning transforms, let the agent inspect your data and write small normalization scripts per column (prices to a standard format, relative URLs made absolute, values validated against the column's type). The import dialog shows the **real, executed** before → after values for each script over a sample of your rows — not just a description of what it plans to do — so you can confirm it does what you expect before importing. Once confirmed, the script is saved on the column and **replays automatically on every future re-import**, so delta re-imports keep normalizing new or changed rows the same way. Scripts run deterministically over every row — no per-row AI cost, only a flat one-time fee for the AI call that writes them.
* **Edit inline** — click any data cell to edit. Select rows with checkboxes for bulk actions. A few column types get a richer cell editor:
* **Select/multi-select** — search existing options or type a new label and create it on the spot, without leaving the cell
* **Image/video/file** — drag-and-drop or browse to upload, or paste a URL directly
* **Date/datetime** — pick a day from a calendar popup instead of typing a date string
## Running agents
Trigger a single cell, a whole column, or your current selection. Batches above your cost threshold ask for confirmation with an estimate first, and re-running a cell whose inputs haven't changed is free — Orisu detects nothing changed and reuses the previous result.
Cells move through clear states: **queued → running → needs review → approved**. Failed cells show the error and a one-click retry. A batch you stop partway through leaves its not-yet-finished cells **cancelled** — a neutral state, not an error — and they can be re-run like any other pending cell.
### Bulk actions
Select rows with the checkboxes and a floating action bar appears with everything you can do to the selection:
* **Run** — pick a run column and Orisu shows a preview first: "Run *M* cells · \~*E* credits" (rows already queued or running are excluded from *M*, so it's never more than what's actually about to fire). Confirm to trigger, or back out — nothing runs until you confirm.
* **Edit cells** — apply a change to a data column across every selected row in one step: **Set value** (type in the new value once), **Copy first row down** (fills the rest of the selection with the top selected row's value), or **Clear**. The input matches the column's type — a calendar for dates, an option picker for select columns, and so on.
* **Duplicate** — clone the selected rows as new rows at the end of the feed (data only; nothing is re-run automatically).
* **Delete** — remove the selected rows.
* The **×** clears the selection.
### Run progress
A thin strip appears above the grid whenever cells in the feed are active. If you triggered the batch from this browser tab, it's a determinate progress bar with a live tally — Running / Queued / Done / Failed — and the estimated credit cost. **Cancel** stops the batch: cells still queued die instantly, and cells already running stop shortly after (they may still bill for the partial work in flight). When everything in the batch has settled, the strip becomes a short summary — succeeded / failed / cancelled counts and credits actually used — and dismisses itself after a few seconds (or click the × to close it now).
If cells are running from elsewhere — another tab, another teammate — the strip shows an indeterminate "N cells running in this feed" line with its own Cancel.
## Viewing and editing outputs
Click an image or video in an output cell to see it full size. The arrows, or the arrow keys, move through the same column one row at a time, and the row's title shows at the bottom. The download button saves the file you're looking at.
Image outputs also have an **Edit** button. It closes the viewer and opens the image in the asset editor, where you can mark it up or describe a change for a model to make. Model edits cost credits, and the editor shows the price before you run one. Each version you make is saved to your [asset library](/guides/managing-creations) as a new image. When you click **Commit**, a message confirms the save, and **View** opens the new image in the library.
Editing doesn't change the feed. The output cell keeps the image the run produced, and the export uses that image too. To get a different result in the cell, re-run it. Videos, and images uploaded into data columns, open in the viewer without an Edit button.
## Review
Click any finished cell to open the review drawer: see the outputs, **approve**, **reject**, or **re-run**, then jump straight to the next cell that needs review. Approving is what makes a row eligible for export.
If the agent contains a [Human Review](/nodes/logic/human-review) node, the run pauses mid-workflow and the cell flips to **needs review** before it finishes. Opening the drawer shows the items waiting at that checkpoint: approve or reject each one (or edit an item before approving it), and the run picks up from there with only the approved items. When the agent's loop produced several items, they all arrive at the checkpoint together — one pass through the drawer reviews the whole set. The cell-level approve/reject stays disabled until the run completes; it applies to the finished result.
## Record view
Rows with a lot of columns are hard to read as a single grid line. Hover any row (or focus a cell and press **Enter**) to reveal an expand icon and open that row as a **record** — a panel on the right showing every column as a labeled field, in column order:
* **Data fields** are editable in place with the same editors as bulk edit — text, number, select, date, and so on. Text, number, and price fields save when you press **Enter** or click away; toggles and single-select fields save the instant you change them; dates, multi-select, and JSON/attributes fields save when you leave the field (they need more than one keystroke to finish an edit). A field left in an invalid state (like malformed JSON) shows an inline error and won't save until it's fixed.
* **Run fields** show a live status chip (queued, running, needs review, and so on) with a **Run** or **Re-run** button when the cell is pending, and **View run** to open the review drawer on top of the record panel once a run exists.
* **Output fields** are read-only — the run's result (image, text, and so on) plus a **View run** link back to the run that produced it.
* **Required** data fields show an asterisk next to their label, with an advisory tint when they're empty.
Use the **prev/next** arrows in the panel header (or the "Row *N* of *M*" position) to step through rows in whatever order the grid is currently displaying — record view respects your active sort and filters. Press **Escape** or click **✕** to close.
## Export
Pick Meta or TikTok, confirm the field mapping, and Orisu generates a hosted CSV at a **stable URL** — paste it once into Commerce Manager or TikTok Catalog Manager and the channel pulls updates on its own schedule. A plain CSV download of the whole grid is always available.
Export checks every mapped field against that channel's real catalog spec, not just the 8 basics — required fields, formats, lengths, and enums (for example Meta's `availability` only accepts `in stock` / `out of stock`, and `price` must be `"9.99 USD"`: an amount plus its ISO-4217 currency code, no symbol). Currency comes from the field mapping's own currency override if you set one, otherwise from the source column's currency setting. A row that fails a required or format check is **blocked** from that export with the specific reason; a fixable issue like an over-length title is a **warning** and gets truncated rather than blocked. Because channel packs get stricter over time (Meta now requires `brand`, for instance), a mapping that used to export cleanly can start blocking rows once a newly-required field has no source — the compliance report always names exactly which field and how many rows are affected, so you know what to map.
Click **✨ Map with AI** to skip hand-mapping fields yourself: Orisu proposes a complete field mapping from your data columns and sample rows, along with a compliance report — **fixable** issues it already patched with a small transform, **blocking** issues that still need a source column, and **warnings** about lossy fixes like truncation. Review it, adjust anything you want, and it's saved on the export column just like a manual mapping — every future export replays it.
Exported images are copied to permanent storage keys, so re-running agents never breaks a live catalog feed.
Normalize with AI and Map with AI (including the copilot's mapping suggestions) each cost a flat, one-time credit fee per call — the script or mapping they produce then runs free over every row, on every future run.
## Copilot
Click **Copilot** in the header to open a chat panel over the grid. It already knows which feed you have open, so you can ask it to read the feed, add or update columns (including settings and type changes — it reports what converted and what was cleared, just like the grid toast), set cells, add rows, estimate what a batch would cost, and run, cancel, or review runs.
Any write the copilot proposes shows as a card you approve or dismiss before it touches your feed, and a run that crosses your cost threshold shows the same estimate-first approval card the grid does — nothing runs until you confirm. Once you approve a change, the grid updates immediately without a reload.
Copilot conversations on a feed aren't saved between page loads yet — closing the panel or leaving the page starts fresh next time.
### Bulk transforms
For anything that touches a lot of rows or needs real logic — "strip the 'SALE —' prefix from every title", "trim whitespace on all SKUs", "uppercase the first letter of every color" — ask the copilot in plain language instead of describing cell-by-cell edits. It writes a small script for the column(s) involved, previews it over a sample of your real rows, and shows you the actual **before → after** values (plus anything it couldn't normalize) before touching anything. Nothing is written until you approve the preview card — applying always shows a confirmation, even in Auto mode.
Once approved, the script runs over the whole feed (up to 10,000 rows per call) in one all-or-nothing pass: either every eligible cell updates, or nothing does. A script returning `null` for a cell clears it; a cell the script fails to handle (it throws, or the result fails the column's type validation) is **rejected** — left unchanged and reported back, never partially written. If some cells are rejected, the copilot can revise the script and re-preview against just those rows.
Scripts run in a locked-down sandbox (no network, no filesystem, bounded size and execution time), so this works for real bulk cleanup without you hand-editing thousands of cells or the agent burning tokens pulling your data through the chat.
## From code and agents
Everything the grid does is also available as [MCP tools](/mcp/overview) (`list_feeds`, `add_feed_column`, `run_feed_column`, `review_feed_cell`, `preview_feed_transform` / `apply_feed_transform`, `suggest_feed_mapping`, …) and on the REST API, so external agents and the in-app copilot can build and manage feeds end to end.