Skip to content
InlayAI

Platform tour

From agent graph to working product.

Build the workflow, connect it to your app, and follow the work from a user's request to a useful result. Here's how the pieces fit together, with your interface, sign-in, and product logic at the center.

01 / Build

Design the work

Give the agent a workflow you can see.

Start with the work your product needs to do: research, draft, review. Connect model calls and tools on the canvas, then add branches, loops, or subgraphs where the workflow needs them. Configure each step and inspect a run as you build.

Try changes in a draft before publishing a version. Pin your app to that contract so you can keep improving the agent without changing the version your users are running. Move the live pointer back when you need a rollback.

Inlay / canvasScreenshot placeholder

The graph behind your product

Trip Planner canvas: a brief, flight lookup, parallel specialists, and an itinerary-to-map hand-off. Include the published version.

Capture / canvas.webp2400 x 1350 px
Product capture to be added. This frame is not a product screenshot.
Read about agent versions

02 / Connect

Bring the result into your app

The agent's work becomes your interface.

Show a document as it takes shape, update a table, or let a person review a proposed action. The TypeScript client, React hooks, and Next.js helpers connect the agent to the experience you build.

Optional code generation gives your published version typed outputs, tool handlers, and progress views. A client tool can ask for a decision in your app, then continue when the user responds. Reopen saved history and pending approvals when they return.

Inlay / outputsScreenshot placeholder

Work your users can act on

The same trip in a labelled example workspace: a live itinerary, highlights, map, and a share preview awaiting the traveller.

Capture / outputs.webp1800 x 1350 px
Product capture to be added. This frame is not a product screenshot.

03 / Knowledge

Ground the work in your knowledge

From source documents to a useful answer.

Bring in your documents and use Retrieval Studio to see what a query finds. Connect an answer to its supporting passages, inspect its citations, and evaluate retrieval as your knowledge base changes.

When the work needs more than documents, connect web search, URL fetch, sandboxed Starlark execution, or compatible MCP tools. Choose the tools the agent can use and keep their credentials on the server.

Inlay / retrievalScreenshot placeholder

An answer with its sources

Retrieval Studio showing a grounded answer and its supporting passages.

Capture / retrieval.webp2000 x 1250 px
Product capture to be added. This frame is not a product screenshot.

04 / Memory

Carry context forward

Remember what belongs to the conversation, user, or agent.

Keep a working draft for this conversation, preferences for this user, or shared context for the agent. Declare fields and collections, then let tools read and update the state the workflow needs.

Your app subscribes to the public fields and collection rows you expose. Internal notes can stay private while a useful document or table updates in the interface.

Inlay / memoryScreenshot placeholder

State that belongs to the product

Safe example memory or a declared collection with stable row identities. Not a list relabeled as a table.

Capture / memory.webp2000 x 1250 px
Product capture to be added. This frame is not a product screenshot.
Explore state, memory, and tables

05 / Users

Connect the person behind the request

Your sign-in. User-scoped agent sessions.

Use your existing sign-in. Once your app has authenticated a user, your server mints a short-lived Inlay session for them. Your app decides what they may access; your Inlay secret key stays on the server.

Give each user their own conversation history, memory, and usage. Workspace membership governs your builders; end-user identity scopes the people using the product they build.

Explicit public outputs can reach the browser. Private credentials and operator traces are not the customer timeline. Configure tool visibility and session scopes for the experience you intend to expose.

06 / Inspect

Understand how the result happened

Follow the work back to the run that made it.

When a result surprises you, inspect the route the agent took, the model requests it made, and what its tools returned. Compare that with the run's version, latency, and token usage as you improve the workflow.

Use operator traces for diagnosis and the SDK's progress and public timeline for your users. Your product can show what is happening while keeping internal call details in the dashboard.

Inlay / tracesScreenshot placeholder

Follow the work, call by call

A settled conversation with a relevant tool or model trace expanded. Remove private payloads.

Capture / traces.webp2000 x 1250 px
Product capture to be added. This frame is not a product screenshot.

07 / Operate

Build the business around the work

Scheduled work, metered usage, and your business model.

Run non-interactive agents on a schedule, with timezones and version pins. Meter model and tool usage, define customer plans and allowances, and bring balances and invoices into your app through the SDK.

Connect hosted checkout and credit top-ups to your paywall using your configured Stripe account. You own the offer and customer experience; your product's pricing is separate from the rates you pay Inlay.

Inlay / billingScreenshot placeholder

The usage behind the business

Usage and a plan or draft invoice from an isolated demo account. Preserve estimated and draft labels.

Capture / billing.webp2000 x 1250 px
Product capture to be added. This frame is not a product screenshot.

Build the product only you can build.

Tell us who it's for and what the agent needs to do. Inlay is in private beta, with access reviewed and onboarding handled manually.