Skip to the Apps guide

Apps

Create an App

Build your own tools that run inside Genaro.

Build your own tools for Genaro

An app is a tool you build that runs inside Genaro. You decide what it does and what information it needs.

When you publish it, it shows up in Genaro as a simple form. A user fills in the form, presses run, and the app does the rest.

Anyone in your Workspace can run it the same way.

Learn

Getting started

The easiest way to build an App is to give the prompt below to a coding agent. It checks the tools on your computer, creates a starter project, and follows the current Genaro instructions included with the SDK.

Is your agent already connected to Genaro over MCP or the API? It can skip the install: it writes the App and publishes the TypeScript, and Genaro builds it.

Prompt for your coding agent · text
Help me build an App for Genaro.

First, check whether this computer has Node.js 22 or newer, npm and pnpm.
If any is missing, explain what needs to be installed and ask for my
permission before installing it from nodejs.org or a trusted system package
manager.

The Genaro Apps SDK is installed from a Genaro checkout. Ask me where mine is,
then install it in this folder:

(cd /path/to/genaro/sdk/apps && pnpm install && pnpm build)
npm install --save /path/to/genaro/sdk/apps   # in your App project

Ask me what I want the App to do and what to call the project folder. Then run:

npx genaro-app create <project-folder> --yes

Open the generated project and read AGENTS.md before writing code. Never ask me
to paste a Genaro API key into this chat or put one in source code. Building
and validating do not need a key. When I explicitly ask to publish or start a
real run, tell me to run `npx genaro-app configure` myself inside the project.

Implement the App, keep t.object at the input and output roots only, update
input.example.json, then run `npm run check` and `npm run validate`. Show me
any decisions you need from me and summarize the validation result.
Or create the project yourself · bash
(cd /path/to/genaro/sdk/apps && pnpm install && pnpm build)
npm install --save /path/to/genaro/sdk/apps   # in your App project
npx genaro-app create
  1. 01

    Copy the prompt

    Give it to a coding agent that can work with files and run commands on your computer.

  2. 02

    Approve setup if needed

    The setup works on macOS, Windows, and Linux. If Node.js is missing, your agent should explain the installation and ask first.

  3. 03

    Describe your App

    Tell the agent the workflow in plain language. It will read the included instructions, build the App, and validate it locally.

The full reference for coding agents is also available as llms.txt.

Create your API key

This is the one setup step you must complete yourself. Open API keys in the Genaro console and create a Workspace API key. You will see the full key once, so copy it before closing the dialog. You do not need it to build or validate. When you are ready to publish or start a real run, personally run npx genaro-app configure inside the project and paste it there.

read

Lets the CLI find your published Apps, follow run progress, and read results and traces.

content:write

Lets the CLI publish Apps and new versions.

generate

Lets the CLI start real runs and answer review steps.

Select all three scopes when you want to publish and test a real run with the same key. Starting a run authorizes the published App to perform its documented actions, charged under the key's model allow-list and spend cap.

Treat the key like a password. The setup saves it in local configuration that is excluded from source control. Do not paste the key into your App code or an agent chat.

Learn

How Apps work

Apps are for creative work that you repeat. An App can generate images, use photos from your Workspace's Assets, create several versions at once, and stop to let a person pick the best one before it continues. A run can wait hours or days for that decision, and it never loses its place. If you follow the same steps every time you produce a certain kind of image, an App can capture those steps once and run them from then on.

Work in parallel

Concept Version A Version B Version C

Put judgment in the middle

The App can pause after creating options, ask a person to choose, then continue using that choice.

Version A Version B Choose A person decides Continue chosen path

Wait without losing progress

Ordinary code has to keep running until it finishes. An App can suspend—or park—while it waits, then resume later from the same place.

Ordinary code runs continuously Run Working Finish App code can suspend hours or days Run Suspend Resume Finish

An App is a small TypeScript program you publish to Genaro. That program defines the form people fill in, the steps that run when they press run, and the result that comes back.

You can write the program yourself, or just hand the downloadable agent docs to a coding assistant and have it create the workflow you describe. Either way, you're shipping real code.

Learn

Anatomy of an app

Every App tells Genaro four things: what it is called, what it needs, what it does, and what it returns.

Listing Name + description Inputs What it needs Execution Your code running Outputs What it returns

Learn

The interface

The input section of your App defines the input form. Genaro reads each field, builds the matching form control, checks the answers, and passes them to your code. There is no separate form to design or keep in sync.

This complete example shows every input type available today and the form it produces. Every declared field is required.

Code

Input schema

Fields, types, and rules

Interface

Form

Matching controls

Complete input schema

app.ts
input: t.object({
  title: t.string({                        // 1
    label: "Title",
    placeholder: "Summer campaign",
    description: "Give this run a name.",
    maxLength: 80
  }),
  notes: t.string({                        // 2
    label: "Notes",
    placeholder: "Make the image bright and playful…",
    description: "Describe the creative direction.",
    multiline: true,
    maxLength: 1000
  }),
  versions: t.number({                     // 3
    label: "Versions",
    placeholder: "Choose a number",
    integer: true,
    min: 1,
    max: 4
  }),
  quality: t.number({                      // 4
    label: "Quality",
    placeholder: "0–100",
    min: 0,
    max: 100
  }),
  transparent: t.boolean({                 // 5
    label: "Transparent background"
  }),
  format: t.enum(                          // 6
    ["Square", "Portrait", "Landscape"] as const,
    {
      label: "Format",
      placeholder: "Choose a format"
    }
  ),
  tags: t.array(t.string(), {              // 7
    label: "Tags",
    placeholder: "One item per line",
    description: "Add one tag per line."
  }),
  image: t.asset("image", {                // 8
    label: "Source image"
  }),
  video: t.asset("video", {                // 9
    label: "Source video"
  })
})

Generated form

Give this run a name.

Describe the creative direction.

One per line.

Add one tag per line.

The ID of an image Asset in this workspace. Copy it from the Asset's page.

The ID of a video Asset in this workspace. Copy it from the Asset's page.

The field key becomes the property your code reads—for example, title becomes input.title. The label supplies the words people see. A placeholder gives them an example inside an empty control, and a description adds helpful guidance beneath it. The field type and its other options determine which control Genaro renders and how it behaves.

Learn

What your App can access

An App can read its form inputs and use a small set of actions built into Genaro. Today those actions include generating media, describing images and video and calling text models, reading your Workspace's assets and groups, adding an asset to a group, asking someone to review work, naming the work for the run's execution trace, and getting recorded random values or timestamps. In the code, these actions are grouped under a value named ctx. You will see it in Your first App, and the Available actions section explains each action in detail.

Built-in actions define what an App can do
Genaro App runtime Your App code Loops · branches · retries Generate Available through ctx Ask a person Available through ctx Web requests Outside APIs Local files Other actions

    Built-in actions do the work

    Your App uses Genaro's built-in actions to work with media, language models, groups, choices, and recorded values.

    Use TypeScript for logic

    Your App can loop, branch on a condition, retry a failed step, and perform steps in whatever order the work requires.

    See what you can build

    The Available actions section shows what your App can do, with examples you can adapt for your own ideas.

Build

Your first App

This App takes a photo and a line of text, and it prints that text onto the person's clothing. It is the smallest App worth writing, and it still travels the whole path from the input form to a finished image in your Workspace. Read it once from top to bottom, then read the four notes below it.

Inside run, Genaro gives your code the ctx value mentioned earlier. It contains the built-in actions your App can use. This example calls ctx.generate.image to create one image.

app.ts · typescript
import { defineApp, t } from "@genaro/apps-sdk"

export default defineApp({ // 1
  slug: "clothing-labeler",
  name: "Clothing Labeler",
  description: "Print custom text onto a person's clothing",

  input: t.object({ // 2
    person: t.asset("image", { label: "Person photo" }),
    text: t.string({ label: "Text to print" })
  }),

  output: t.object({
    image: t.asset("image")
  }),

  async run(ctx, input) {
    const result = await ctx.generate.image({ // 3
      model: "krea2",
      references: [input.person],
      prompt:
        `Keep the same person and outfit, but print "${input.text}" ` +
        `clearly on the front of the clothing`
    })

    return { image: result.assetId } // 4
  }
})
  1. 01

    defineApp

    This declares your App. It gives Genaro the name, the description, the shape of the form, and the code to run. Every App calls it once.

  2. 02

    t.object

    This wraps all the fields your App needs. Use it once at the input root and once at the output root; it cannot be nested inside another field.

  3. 03

    Generate the image

    ctx.generate.image asks Genaro to create one image. This is the step you pay for, and the App automatically waits until the image is ready. Because this call passes references, it runs the krea-2-edit model over the selected photo instead of painting a new person from scratch.

  4. 04

    return

    This hands back what the App produced. Genaro shows the returned image when the run finishes.

Use selected media in later steps

An image field takes the ID of an Asset in your Workspace. In the example above, input.person is passed directly to references so the generation uses the photo that person selected.

Build

Waiting happens automatically

A generation may take time. A person may not answer a choice until tomorrow. When something is not ready, Genaro automatically suspends the App and waits. As soon as the result or response is ready, the App continues from the same place.

You do not need to manage the waiting yourself.

App code interacts with the outside world only through actions Genaro provides. Those actions record what happened before the App waits, which is what lets the run continue safely from the same place later. The Capabilities section lists the actions App code can use.

Build

Pause for human review

Some decisions need a person, not another automated step. Add a review wherever you want someone to approve the work, choose a direction, or check the details before the App moves on.

Genaro automatically suspends the App and waits until the review is complete. It then continues with the answer.

Description What people see TypeScript

Approval

approval

One go or no-go decision for a deliverable, launch, or handoff.

Returns

approved · rejected

const approval = await ctx.review.approval({
  title: "Approve this campaign",
  subjects: imageOptions,
  approveLabel: "Ready for client",
  rejectLabel: "Keep working"
})

Select one

selectOne

Choose exactly one direction from a set of options.

Returns

one option value

const heroId = await ctx.review.selectOne({
  title: "Choose the hero image",
  options: imageOptions
})

Select many

selectMany

Build one shortlist. Set a minimum and maximum to control its size.

Returns

a list of option values

const shortlist = await ctx.review.selectMany({
  title: "Build the client shortlist",
  options: imageOptions,
  min: 2,
  max: 3
})

QA checklist

checklist

Check every named criterion with Pass, Fail, or an allowed N/A.

Returns

one result per criterion

const qa = await ctx.review.checklist({
  title: "Complete preflight QA",
  subjects: imageOptions,
  criteria: [
    { id: "brand", label: "Matches the brand direction" },
    { id: "copy", label: "All visible copy is accurate" },
    {
      id: "legal",
      label: "Required legal copy is present",
      allowNotApplicable: true
    }
  ]
})

Review each

reviewEach

Give every item its own decision and add feedback when changes are needed.

Returns

one decision per item

const review = await ctx.review.reviewEach({
  title: "Review every campaign asset",
  items: imageOptions.map((option) => ({
    id: option.value,
    label: option.label,
    assetId: option.assetId
  }))
})
Select many creates one shortlist. Review each records a separate decision for every item.

Choose the review type that matches the decision you need. The returned answer is available on the next line, ready for the App to use.

Build

Inputs and outputs

Every App declares a schema for what it takes in and a schema for what it gives back. Each line in the input schema creates one control in the form people fill in before they press run. A t.string line creates a text field. A t.asset line creates a field for the ID of an Asset in your Workspace. The same schema also gives your code its TypeScript types, so run knows exactly what it received. Every field is required unless you build it with optional: true, in which case people may leave it blank and your code sees undefined.

Here is the control that each schema line creates.

Schema line Type Control people see Example in the generated form
t.string string Text field or textarea
t.number number Number field
t.boolean boolean Checkbox
t.enum literal union Select
t.array array Textarea, one entry per line

One per line.

t.asset asset ID Asset ID field

The ID of an image Asset in this workspace. Copy it from the Asset's page.

t.object object Complete form or result

t.object wraps the complete input or output. It is only supported at those two roots, not as a nested field or inside t.array. TypeScript and local validation both catch that mistake.

Write labels for people, not for code

The key names the field in your code. The label is the text someone reads in the form, so write it the way you would say it out loud.

Return asset IDs from your output

An output that returns an asset ID connects the finished result to your Workspace's Assets. The run's page shows it as a preview, and the image your App produced behaves like the rest of your media.

Build

Capabilities

App code can use the actions Genaro deliberately provides. It cannot reach the internet, local files, secrets, or outside services directly. Keeping those boundaries explicit is what lets Genaro pause a run, resume it later, and continue under the authorization of the API key that started it.

Apps can

  • Create forms with typed inputs and results
  • Generate and edit images and generate video with any Genaro model
  • Read the assets and groups of the run's Workspace
  • Call Genaro text models for chat and image or video description (billed to your balance)
  • Add generated media to an existing group
  • Run several generation steps in parallel
  • Pause for approvals, selections, QA, and per-item review
  • Name spans of work for the run's execution trace
  • Use recorded time and random values when a workflow needs them
  • Wait for hours or days and resume from the same place

App code can't

  • Make arbitrary web requests or call outside APIs
  • Read local files, environment variables, or secrets
  • Use raw secrets or provider credentials
  • Create schedules, timers, or background triggers
  • Store private App data between runs
  • Upload assets, or create or delete groups

Apps can only interact with the outside world through the capabilities listed here. If you think something is missing, contact us—we may be able to add it.

Build

Actions your App can take

ctx is the name used in code for actions Genaro provides. Your App can use it to generate media, extract video frames and stitch clips, describe images and video and call text models, read your Workspace's assets and groups, add an asset to a group, ask someone to choose, name the work for the execution trace, get a random number, or read the current time. Every action runs as the API key that started the run and stays inside its Workspace. If an action needs time, the App automatically waits until it is ready.

ctx.generate.image({ prompt, references?, model? }) Paid generation

This creates one image and gives you back its asset ID. If you pass only a prompt, it generates a new image from that text. If you pass asset IDs in references (at most two), it edits those images instead. The only model you can name today is "krea2", and that name selects a family rather than one checkpoint: with references the call runs krea-2-edit, and a prompt on its own runs krea-2 text-to-image.

Resolves to { generationId, assetId, assetIds }

ctx.generate.media({ model, params, provider? }) Paid generation

This runs any supported image, video, or audio model. Use the same model name and parameters shown in the model catalog and POST /api/v1/generations. Images and videos you pass in are asset references, { asset_id: "..." }, from your Workspace.

Resolves to { generationId, assetId, assetIds, data? }

ctx.media.firstFrame({ videoAssetId }) · ctx.media.lastFrame({ videoAssetId }) Free

Save the first or exact last decoded frame as an image Asset in the same Workspace. Repeating the request reuses the result. Requires read and content:write on the run's key.

Resolves to { assetId }

ctx.media.stitch({ videoAssetIds }) Free

Join 1–16 videos in the order you pass them and save a new video Asset with lineage to every input. Different dimensions, frame rates and codecs are normalized to the first clip's dimensions and frame rate. Audio is retained only when every clip has audio; otherwise the result is silent. Repeating the same ordered inputs reuses the result. Requires read and content:write. Video derivations accept up to 200 MB of input, 120 seconds of total video, 3840 pixels per side, 8.3 megapixels and 60 fps. Output stays under 200 MB; processing has a three-minute budget and may fail when a limit is exceeded.

Resolves to { assetId }

ctx.assets.get(id) · ctx.assets.list(filters?) Free

Find images, videos, and audio your Workspace can already access in Genaro, or look up one asset by its ID.

Resolves to Asset | null · Asset[]

ctx.groups.get(id) · list() · items(id, page?) · addAsset(groupId, assetId) Free

Browse your Workspace's groups, read the assets inside them, and add a Genaro asset to a group. Adding an asset that is already there changes nothing instead of adding a duplicate.

Resolves to Group · { items, cursor, hasMore } · Group

ctx.llm.chat({ messages, model, temperature? }) Text model

Call a Genaro text model; usage is billed to your balance per call, from the tokens it used. Messages use roles system, user, and assistant. A run may make at most 30 text model calls.

Resolves to { content, model }

ctx.llm.describeImage({ assetId | assets, prompt, model }) Text model

Describe one or more image assets with a vision model. Genaro resolves the media; your script only passes asset IDs and a prompt.

Resolves to { content, model }

ctx.llm.describeVideo({ assetId, prompt, model }) Text model

Analyze a video asset with a video-capable text model, the same way.

Resolves to { content, model }

ctx.review.approval({ title, instructions?, subjects?, approveLabel?, rejectLabel? })

Ask for one explicit go or no-go decision. Optional subjects can be asset-backed options so the reviewer sees the work being approved.

Resolves to { decision: "approved" | "rejected" }

ctx.review.selectOne({ options, title, instructions?, submit? })

This durably stops the run and asks a person to pick one of the options you passed in. It appears in the console under Apps › Reviews and survives server restarts. The App can wait for hours or days without costing anything, then continue under the authorization of the API key that started the run.

Resolves to string

ctx.review.selectMany({ options, title, instructions?, min?, max? })

Ask for a shortlist. The person submits a unique set of option values within the minimum and maximum you provide.

Resolves to string[]

ctx.review.checklist({ criteria, title, instructions?, subjects? })

Require a QA result for every criterion. N/A appears only on criteria where the App explicitly allows it.

Resolves to { results: Record<string, "pass" | "fail" | "not_applicable"> }

ctx.review.reviewEach({ items, title, instructions? })

Require an individual disposition for every item before the run continues. “Changes requested” also requires actionable written feedback for that item.

Resolves to { decisions, feedback }

ctx.trace.span({ name, key?, attributes? }, (span) => …) Free

Group steps into a named span so the run's execution trace reads like your process. Use the span context inside the callback so its steps belong to the span.

Resolves to { value, spanId }

ctx.random() Free

This gives you a random number that is at least 0 and less than 1. Genaro keeps that number consistent for the entire run.

Resolves to number

ctx.now() Free

This gives you the current time in epoch milliseconds. Genaro keeps that timestamp consistent for the entire run.

Resolves to epoch milliseconds

Find media your Workspace already has

Use these list methods when an App needs to choose from existing media or groups before it generates anything new.

Browse Workspace resources · typescript
const images = await ctx.assets.list({
  mediaKind: "image",
  limit: 25
})

const groups = await ctx.groups.list()

const page = await ctx.groups.items(input.groupId, { limit: 25 })

Build

Common recipes

Each recipe below adds one new idea to the first App. Read the one that matches what you want to build, then hand it to your AI assistant as the starting point.

Generate several versions at once

Use this when someone should compare directions instead of accepting the first result. The generations run at the same time, so you wait once rather than once per image.

Parallel image variants · typescript
const styles = ["watercolor", "editorial", "neon"] as const

const variants = await Promise.all(
  styles.map((style) =>
    ctx.generate.image({
      prompt: `${input.subject}, ${style} style`
    })
  )
)

const imageIds = variants.map((variant) => variant.assetId)

Pause for a person, then refine their choice

Use this when a person should judge the work before the App continues. The App automatically suspends while it waits, then continues from the same place once someone chooses.

Human-guided refinement · typescript
const variants = await Promise.all(
  ["warm", "cool", "monochrome"].map((palette) =>
    ctx.generate.image({
      references: [input.photo],
      prompt: `Restyle this photo with a ${palette} palette`
    })
  )
)

const chosenId = await ctx.review.selectOne({
  options: variants.map((variant) => variant.assetId),
  title: "Choose the direction to refine"
})

const refined = await ctx.generate.image({
  references: [chosenId],
  prompt: "Polish this direction for a finished campaign image"
})

return { image: refined.assetId }

Save a generated image to a group

Use this when the finished result belongs in a group your Workspace already uses. The generated image is still an ordinary Asset in Genaro, and the App also files it into the chosen group.

Generate and save · typescript
const result = await ctx.generate.image({
  prompt: input.prompt
})

await ctx.groups.addAsset(
  input.groupId,
  result.assetId
)

return { image: result.assetId }

Turn an image from a group into a video

Use this when an App should start with media your Workspace has already organized. It reads a page from the group, picks the first image, and sends that asset to a video model.

Group to video · typescript
const page = await ctx.groups.items(input.groupId, { limit: 25 })
const source = page.items.find((asset) => asset.mediaKind === "image")

if (!source) {
  throw new Error("This group has no image")
}

const result = await ctx.generate.media({
  model: "seedance-v2-fast",
  params: {
    prompt: input.motion,
    image: { asset_id: source.id },
    duration: 5
  }
})

if (!result.assetId) {
  throw new Error("The video model returned no asset")
}

return { video: result.assetId }

Chain video clips, then stitch them

Start each new clip from the previous clip's last frame for visual continuity. Frame extraction and stitching are free; each generation is paid. Keep the chain within 16 clips and 120 seconds.

Chained video · typescript
const clips = [input.firstClip]

for (const prompt of input.nextPrompts) {
  const frame = await ctx.media.lastFrame({
    videoAssetId: clips[clips.length - 1]
  })
  const next = await ctx.generate.media({
    model: "seedance-v2-fast",
    params: { prompt, image: { asset_id: frame.assetId }, duration: 5 }
  })
  if (!next.assetId) throw new Error("The video model returned no asset")
  clips.push(next.assetId)
}

const stitched = await ctx.media.stitch({ videoAssetIds: clips })
return { video: stitched.assetId }

Branch on time or randomness safely

Use ctx.random and ctx.now whenever a decision depends on chance or on the clock. Genaro keeps both values consistent for the entire run.

Saved values · typescript
const randomValue = await ctx.random()
const startedAt = await ctx.now()

const direction = randomValue < 0.5 ? "minimal" : "expressive"

const result = await ctx.generate.image({
  prompt: `${input.subject}, ${direction} art direction`
})

return {
  image: result.assetId,
  startedAt
}

Recover from a step that failed

Use this when one generation might fail and you would rather make a simpler attempt than lose the run. An ordinary try and catch is enough to start the fallback.

Generation fallback · typescript
let assetId: string

try {
  const primary = await ctx.generate.image({
    prompt: input.ambitiousPrompt
  })
  assetId = primary.assetId
} catch {
  const fallback = await ctx.generate.image({
    prompt: input.simplePrompt
  })
  assetId = fallback.assetId
}

return { image: assetId }

Describe media with an LLM

Use this when you need text from an image or a short caption before a human review. Billed to your balance per call.

Describe and caption · typescript
const { content: description } = await ctx.llm.describeImage({
  model: input.visionModel,
  assetId: input.photo,
  prompt: "Describe wardrobe, lighting, and pose in one short paragraph."
})

const { content: caption } = await ctx.llm.chat({
  model: input.textModel,
  messages: [
    { role: "system", content: "You write short social captions." },
    { role: "user", content: `Write a caption for: ${description}` }
  ]
})

return { description, caption }

Ship

Publish from source

An agent connected to Genaro over MCP or the REST API needs no install and no build step. It sends the App's TypeScript to genaro_publish_app (or POST /api/v1/apps) as source, one file, or as files with the entry that default-exports the App. Genaro builds the bundle with the same settings as genaro-app build and the SDK version it ships, then publishes it like any other version.

Publish TypeScript · text
# One file: the MCP tool genaro_publish_app (or POST /api/v1/apps, same body)
{
  "name": "Clothing Labeler",
  "source": "import { defineApp, t } from \"@genaro/apps-sdk\"\n\nexport default defineApp({ ... })\n"
}

# Several files: name the one that default-exports the App
{
  "name": "Clothing Labeler",
  "entry": "app.ts",
  "files": {
    "app.ts": "import { defineApp, t } from \"@genaro/apps-sdk\"\nimport { labelPrompt } from \"./prompts\"\n...",
    "prompts.ts": "export function labelPrompt(text: string): string { ... }\n"
  }
}

# Source that does not build publishes nothing and says where (422)
{
  "error": {
    "type": "app_build_failed",
    "message": "The source did not build, so nothing was published: prompts.ts:3:1: Unexpected end of file",
    "diagnostics": [
      { "file": "prompts.ts", "line": 3, "column": 1, "message": "Unexpected end of file" }
    ]
  }
}

Imports

Only @genaro/apps-sdk and the App's own files, by relative path. npm packages are refused at the import. Up to 50 .ts, .js or .json files, 1 MiB in total.

Build errors

Source that does not build publishes nothing. The error lists each problem with its file, line, column and message, so the agent can fix it and publish again.

Types

The server checks syntax and imports, not types. A type mistake surfaces when a run reaches it, so typecheck first when tsc is available.

Same source, same version

Publishing identical source again reuses the version. Your files and source map are stored with it, so run traces show your TypeScript.

Ship

Publish and run

Ask your coding agent to check the App, publish it, and start one small real run. First, personally run npx genaro-app configure so the project has your API key without exposing it in agent chat. Publishing creates a new version in Genaro without changing runs that are already in progress.

Publish to Genaro · bash
npx genaro-app build app.ts
npx genaro-app publish app.bundle.js
npx genaro-app run <app-id-or-slug> --input input.example.json

Published versions never change

When you submit new code, Genaro stores it as a new version instead of replacing the old one. A run that is already in progress finishes on the exact version it started with.

Waiting happens automatically

The App automatically suspends while it waits for a generation or a person's response, then continues when it is ready.

Run it from anywhere

A published App also runs from its page in the console's Apps, where you pick the API key the run acts for. Review steps are answered in Apps › Reviews or on the run's page. Programs and agents use the same operations over the REST API and MCP:

Operation REST (/api/v1) MCP tool
List and get Apps GET /apps GET /apps/{app_id} genaro_list_appsgenaro_get_app
Publish from TypeScript source or a bundle POST /apps genaro_publish_app
Archive an App POST /apps/{app_id}/archive genaro_archive_app
Start a run POST /apps/{app_id}/runs genaro_create_app_run
List and get runs GET /app_runs GET /app_runs/{app_run_id} genaro_list_app_runsgenaro_get_app_run
Read a run's execution trace GET /app_runs/{app_run_id}/trace genaro_get_app_run_trace
List and get review steps GET /app_reviews GET /app_reviews/{app_review_id} genaro_list_app_reviewsgenaro_get_app_review
Answer a review step POST /app_reviews/{app_review_id}/resolve genaro_resolve_app_review