Skip to content
E-commerceFind, track and return orders.BankingSpending, cards and transfers.TravelConnections and rebooking.TelecomBills and roaming passes.InsuranceClaims from one sentence.
AnswersTheir own data, shown as your app’s cards instead of a paragraph.ActionsTasks done through your API, confirmed with a tap or undone with one.VoiceThey say what they need and the app does it.MemoryRemembers what each person prefers and uses it the next time they ask.Your brandLooks like your app on iOS, Android and the web.Setup by your agentYour coding agent adds it and fills in the console.EngageMessages people asked for, written for you and sent with one tap.AnalyticsWhat people did, what they asked, and what got solved.Human supportYour team answers inside the app, with the conversation in hand.ImproveAnswers ready for what it missed, and requests counted by who asked.Why RendelA chatbot talks about your app.How it worksThe six steps of a turn.SecurityWhat nothing happens without.CompareNext to the alternatives.
DocsEverything, in eighty pages.FlutterThe package, on iOS and Android.WebOne script tag.React NativeSoonPlanned.SwiftSoonPlanned.KotlinSoonPlanned.
BlogWhat we are working out.GlossaryThe words, one sentence each.
Setup by your coding agent

Your coding agent sets it up. You review one branch.

Rendel is the AI assistant that lives inside your mobile app or website and gets things done for your customers. Your developer’s own coding agent adds it on a new branch and fills in your console from your code, and nothing reaches your users until Rendel’s own checks pass.

Try the consoleBook a Demo

Halden’s console, an invented store with Rendel running. Yours for two hours, no sign-up.

Halden’s setup, as Home showed it

Each step lands on Home as the agent works.

Today

An assistant is usually a project before it is a feature.

Whether you pick a chatbot tool your team configures by hand or staff an integration project, someone has to teach it your app before a customer sees anything.

Someone has to teach it everything

It arrives empty. Someone writes the answers, keeps them current, and sets up each thing it may do for a customer, one connection at a time.

Code and configuration live apart

A developer wires in the SDK and sign-in while someone else styles a widget and writes its rules in a dashboard. Then someone still has to test the whole thing before customers do.

Your next release leaves it behind

You ship a screen or an endpoint, the assistant never hears about it, and a customer may be the first to find the gap.

How it works

From one prompt to a console that is ready to test.

Your developer picks the coding agent they already use and pastes one prompt. The agent does the work on a branch, and Home shows each step as it happens.

Read the setup guide
Getting started

Whoever opens the account decides who runs it.

Nobody has to learn a new tool. The person who knows the code does the setup with the agent they already use, and everyone else follows it from Home.

Decide who sets it up, and hand it over in one link

Whoever opens the account picks “I’ll set it up” or “A developer on my team”, or decides later. Type the developer’s work email and Rendel sends one link: they join as a Developer, who can set up the assistant but cannot see billing or manage the team, and Home shows each step until the app goes live.

Keep the coding agent your developer already uses

Pick it from the six in the console’s list, among them Claude Code, Cursor, Codex, Windsurf and Gemini CLI, and Home shows that agent’s own steps and prompt.

Ways in

Connect your agent to Rendel’s MCP server, or have it write a file.

Connected, your agent fills in the console as it works. With the setup file, it sends nothing anywhere and you import what it wrote. Both write the same settings.

Connect your agent once, and the console fills in as it works

Add Rendel’s MCP server once per computer, sign in once in your browser and allow Rendel’s 13 tools once by name, the same fixed set for every app. Then each setup or sync starts from a prompt you paste, and every step lands in your console.

Connect Claude Code to Rendel once, and it does the whole setup for you while this page fills in.

One sign-in that reaches only the apps you could set up yourself

You approve the agent once in your browser. Each run works on the one app your prompt names, your role is checked on every call, and the sign-in ends 30 days after its last use or as soon as you leave the organization.

Or let it write a file, and send nothing anywhere

For teams whose agent or policy will not call an outside service. The agent adds the SDK and describes your app in rendel/setup.json, and you import the file with one command or by dropping it on Home.

A refused file changes nothing

The import checks the whole file before it writes anything. A refused file leaves your console as it was, the fixed file goes in with the same command, and a very large knowledge base can go first in a file of its own.

Or set it up by hand, to the same standard

If your rules keep code away from agents, your developers add the SDK themselves and fill each page through the console’s own forms. The same five server checks decide when you go live.

In your code

It adds to your app and removes nothing.

Rendel’s guide has the agent check your tree is clean, work on a new branch, add only what Rendel needs, and commit without pushing.

Your code changes arrive on a branch of their own

The agent checks that your tree is clean, works on a new rendel/setup branch, adds to your screens and flows without removing anything, and commits without pushing, so your team reviews and merges it as usual.

The SDK goes in the way your app is built

In a Flutter app it adds the package, starts Rendel before your app runs, adds the iOS and Android permission lines it needs, and puts a way in where your own buttons are: floating, in the app bar or in the tab bar. On a website it adds one script tag to every page.

Your signed-in customers stay themselves

At sign-in the agent tells Rendel who the person is by your own user id, never an email or phone number, and hands the SDK the token your app already sends to its own API, so Rendel acts as that person. At sign-out it resets. An app without sign-in skips this step.

It records what matters and masks what is private

Where it finds them, it records sign-ups, purchases, add to cart and checkout started, with ids and amounts only, never a name or anything typed. A screen that shows a balance or private messages is wrapped in RendelMask.

It leaves notes for whoever comes next

The agent tells Rendel your app’s own sign-in and sign-up requests, field names only and never a value, so the Test page can sign in as a test user, and where your code lives, so connecting GitHub suggests the right folder. A short Rendel section in your CLAUDE.md or AGENTS.md tells the next coding agent where Rendel lives and asks for a sync after each new screen or API call.

In your console

Your console arrives filled in from what your app already says.

Your look, the assistant’s voice and rules, its knowledge, the screens it may open and the actions it may take, all from your code and copy, and all yours to change.

Your look, with the file each value came from

Colours, surfaces, corners, type, card and button style, a dark theme if your app has one, and your logo go from your code into the Appearance draft. Each value says where it came from until you change it, and a contrast problem comes with a fix on the same hue.

Knowledge written from what your app already says

Your public pages are added as links that Rendel’s servers fetch, and the agent writes help texts from your code and in-app copy: facts only, never code, secrets or user data. Each one is indexed as soon as it is written and marked AI setup.

Knowledge

An assistant that speaks for your brand from the first day

The agent drafts the assistant’s name, tone, instructions, rules that start with Always or Never, topics to decline, languages, and a welcome screen with up to four suggestions. They are published when the setup finishes, and reach your users once the Go live checks pass. You can change any of them in Experience.

Experience

Every API call your app makes, ready as an action

Each call becomes an action marked read, write or destructive. A write carries the sentence your customer confirms and what your app reloads afterwards, and an endpoint that needs a shared key is saved switched off until a person adds the key.

Screens it may open, planned until your build proves them

For each screen a customer might ask to open, the agent adds registerRoute in your code and declares the screen in the console. It shows as planned until a build that registers it runs.

Screens

Before launch

It proves itself before your users can reach it.

The steps Rendel can check are ticked by what its server saw. Your app has to call in, the answers have to come from your information, and the live key stays locked until five checks pass (six for a website).

Follow every step on Home as it happens

Home draws the run as 13 steps, each with what it did, and the agent’s latest line. If the agent goes quiet, Home says it may be asking you something in its own window. With the setup file, Home fills in when you import it.

Claude Code is setting up Halden

Verifying waits until your app calls in

The agent runs your tests, analyzer and a debug build, then opens the app once with the test key. “Building and verifying” turns green only when Rendel’s server sees your app call in with its screens and actions.

Rendel tests its own answers before your users do

It asks the assistant three to five questions drawn from your setup and checks each answer came from your information or one of your actions. It needs 80% to pass. A miss says why and where to fix it, the agent rewrites what fell short once, and these test conversations are not billed.

Check questions passed

A live key that stays locked until five checks pass

Your customers cannot reach the assistant until Rendel’s server has seen five things: your app connected, its actions and screens, a ready knowledge source, passing check questions, and a way to reach your team. A website also has to list its domains. The same checks hold for an agent’s setup and for one done by hand, and when the app goes live, each owner of your organization gets one email saying so.

Go live

Go live now?

Your users start reaching your assistant, and their messages count toward your plan. You can't take the app back to not live: after this, changes from your code come in through Sync with code, where you review them first. You can keep testing with the test key.

Go liveCancel

It ends with a report, and only the to-dos a person must do

The run closes with a summary, the files it changed and a short list of what only you can do, such as a key it could not enter. A first setup then publishes the look and the assistant, and turns the live key on once all five checks pass; if one is still open, Home names it.

Claude Code set up Halden

Control

Your agent gets what it needs and nothing it should not have.

It needs no secret, on a live app it only proposes changes, and every change it makes is under its own name in your audit log.

The agent needs no secret, and anything that looks like one is refused

There is no field for a key, and only publishable keys go into your code. Rendel scans every write on both paths and refuses anything that looks like a credential, naming the field and never the value. An endpoint that needs a shared key is saved switched off until a person enters it in the console.

On a live app, the agent only proposes

Once you are live, your agent changes the app through a sync, or through a setup that adds its other codebase, such as its website beside its phone app. Every change it sends waits in Sync review until someone on your team applies it.

Add another codebase

Stop it whenever you want

One session per app runs at a time, for up to 24 hours, and a new one ends the last. Stop it on Home or in Settings and the agent’s next request is refused, while what it saved stays. It also ends if the person who started it leaves the team or loses the right to change the app.

Your agent's next request will be refused and its file stops working. Whatever it has already saved stays.

Stop the setup

Every change carries the agent’s name, not yours

Each write is logged under the setup session, so your audit log tells your agent’s changes from a person’s.

Settings › Audit log

A run that stops says why, and picks up where it left off

The step turns red with the agent’s own reason, and what it saved stays and is updated, not copied, on the next run. You can run it again, switch agents or use the setup file, and the person who started an unfinished setup gets an email after a day and again after three.

Run it again without making copies

Everything the agent writes is keyed by a name it chooses, so running setup again or a later sync updates what is there instead of adding a copy. Nothing it writes deletes anything: something gone from your code comes back from a sync as a proposal to archive it.

Knowledge

After launch

Ship your next feature, and Rendel keeps up.

Each build tells Rendel what it can do, Home says when something is new, and one sync with your agent brings Rendel level. On a live app every change waits for your yes.

After each feature, one sync brings Rendel level

Press Sync with code, say in one sentence what changed if you like, and paste the prompt. The agent starts from your sentence, checks the rest of your code against what Rendel holds, and sends only the differences, each with its reason. Something your sentence asks for that the code does not have yet is reported back, not invented.

Sync with code

On a live app, every change waits for your yes

Each proposal shows what it was, what it would become and your agent’s reason, grouped by look, assistant, knowledge, actions and screens. Apply them all, one at a time, or reject them. Look and assistant changes land in their drafts, which you publish as usual.

Sync review

Home notices what a new build added, and when an API document changes

Each time your app starts, the SDK tells Rendel its screens and actions, and anything Rendel was not told about raises a band on Home that opens the sync, with no reload needed. Actions imported from an API document are watched too, and a change to that document shows as its own row.

Home

Connect GitHub to catch screens a build never reports

Give Rendel’s GitHub app read-only access to your app’s repository, and every push to your default branch is checked for screens and endpoints Rendel does not know yet, even a screen added and never registered. Home names each one with its file and commit, and Sync with code opens with them written in.

  • Optional
In the demo console

See a finished setup in Halden’s console.

Halden is an invented shoe store whose developer set Rendel up with Claude Code. The demo cannot run a setup, since nothing of yours is connected, but two of its pages show what the run left behind.

The setup’s own report

In Settings › AI setup sessions: Setup by Claude Code, completed, with its summary, the five files it changed and the two things it left for the team. The sync from ten days ago sits above it.

Who did what

At the bottom of Settings › Audit log, newest first: the team’s rows from launch day (the app going live, a contact channel added, the check questions run again), and under them the setup agent’s own rows, back to the moment it started.

Settings › Audit log

Try it in the demo console

It opens on Capabilities › Actions, where six actions carry the AI setup badge and the two the team added later say Manual. Knowledge holds the nine sources the agent wrote, and Settings the two pages above. Setup itself is switched off in the demo, since nothing of yours is connected.

Try the console
Compared

Next to a chatbot tool your team sets up by hand

Both can answer your customers. What differs is who does the work, what it learns from, and what stays true after your next release.

TopicRendel, set up by your coding agentA chatbot tool, set up by hand
Who does the workYour developer’s coding agent, in your repository, on a branch you reviewSomeone on your team writes the content and configures each connection in the tool’s dashboard
Where answers come fromYour public pages, plus texts the agent writes from your app’s code and copyHelp articles, files or a website you point it at, kept current by your team
Doing things for the customerThe API calls your app already makes, saved as actions, with writes confirmed by the customerEach action built by hand: its address, sign-in, inputs and a test
Proof before launchCheck questions and five Go live checks before the live key worksA preview, and a draft you set live when you are happy with it
After your next releaseA band on Home and one sync with your agent; on a live app, each change waits for reviewYou update content and connections by hand when your app changes
Keys and secretsNo secret needed in your repository or prompt; anything that looks like one is refusedAn auth token entered in the tool for each connection that needs one
If code may not go to an agentSet it up by hand in the console’s forms, held to the same five checksSet up by hand, the usual way
Controls and privacy

You decide who runs it, what it reaches, and when it stops.

Setup sends no customer data. Your code stays with your own agent, and Rendel gets only what the agent writes into the console.

Who can do what

What they can doOwnerAdminDeveloperAnalyst, Conversation reviewer, Customer support
Start a setup or a sync, import a file, stop a sessionYesYesYesNo
Approve an agent’s sign-inYesYesYesNo
Run check questions, go live, apply or reject Sync reviewYesYesYesNo
Hand the setup to a teammateYesYesNoNo
Connect or disconnect GitHubYesYesNoNo
See the Go live checks and past setup sessionsYesYesYesYes

A teammate limited to some apps can set up only those. An invited developer joins every app as a Developer, and an owner can narrow it.

What reaches Rendel, and what does not

  • Rendel does not run your agent and does not receive your repository on either setup path.
  • It gets what the agent writes: route and screen names, theme values with their file, your logo, help text written from your app’s copy, and descriptions of your API calls, plus a short report: where your code lives (remote, branch, folder) and the field names, never the values, of your sign-in and sign-up requests. With the setup file, only the file you import.
  • The agent cannot reach your conversations, your users, your billing or any key but the two publishable ones.
  • Your public pages are fetched by Rendel’s servers, never by the agent, and the agent is never handed a fetched page’s text.
  • Your coding agent’s own model provider sees your code under your agreement with them, as it does for everything else your agent does.
  • If you connect GitHub, Rendel reads changed files in memory and keeps names, file paths and commits, not the files. GitHub is listed among our sub-processors.

Where it is kept, and for how long

  • Stored in Frankfurt (AWS eu-central-1).
  • Setup sessions, their steps, summaries and sync proposals are kept with your app and deleted with it.
  • Setup codes, import codes and agent sign-ins are stored only as hashes.
  • Disconnecting GitHub deletes every finding it made.

What you can switch off or stop

  • Use the setup file, and the agent sends nothing anywhere.
  • Decline the sign-in, or let it end: it lapses 30 days after its last use and as soon as you leave the organization.
  • Stop a running session on Home or in Settings. The agent’s next request is refused.
  • Reject any change in Sync review.
  • Disconnect GitHub, or uninstall Rendel’s app from your GitHub settings.
  • Skip the agent entirely and set it up by hand.
Turn it on

What you need to start

A Flutter app or a website, a coding agent from the list, and someone who can change the app in Rendel. There is nothing to switch on first.

Your app

Flutter apps for iOS and Android, and websites. Setup adds Rendel’s Mobile SDK for Flutter, v0.82.0 (your app needs Flutter 3.29 / Dart 3.7 or newer, JDK 21 on Android), or the Web SDK 0.57.0. Native iOS, native Android and React Native are planned.

Your coding agent

Any of the six in the console’s list can write the setup file, and five of them can also connect to Rendel’s MCP server. To import the file on Windows, use Git Bash or WSL.

Your plan

AI setup, sync, the MCP server, the setup file and GitHub are on every plan, the $0 Pilot plan included, and check questions are not billed. Once you are live, each answer Rendel writes counts as a message on your plan.

What is still yours

Merge the branch and ship your release build, add any key an endpoint needs under Actions, and list your website’s domains under Settings, Security.

What teams ask before they start.

  • The console lists six, among them Claude Code, Cursor, Codex, Windsurf and Gemini CLI. Five of the six, all but Windsurf, can connect to Rendel’s MCP server and fill in your console as they work. All six can write the setup file instead, which sends nothing anywhere.

  • No. Rendel’s guide has it check that your tree is clean, work on a new rendel/setup branch and commit without pushing, so your team reviews and merges it like any other change. A later sync does the same on rendel/sync.

  • It adds the SDK with the test key in debug builds and the live key in release builds, a way into the assistant, your sign-in so Rendel acts as the signed-in person, the screens a customer might ask to open, and a short note for the next coding agent. It removes nothing.

  • Your look and logo, the assistant’s name, tone and rules, knowledge from your public pages and from texts written from your app’s copy, the screens it may open, and your API calls as actions. You can change any of it by hand afterwards.

  • Not on either setup path: Rendel does not run your agent and does not receive your repository. It gets what the agent writes into the console. Your agent’s model provider sees your code under your agreement with them. If you connect GitHub, Rendel reads changed files in memory and keeps names, paths and commits.

  • None are needed. Only publishable keys go into your code, and Rendel refuses any write that looks like a password, API key or token, on both paths. An endpoint that needs a shared key is saved switched off, and a person enters the key in the console.

  • A first setup publishes the look and the assistant, and turns the live key on once all five Go live checks pass (a website also has to list its domains). If one is still open, such as no way yet for customers to reach your team, Home names it, and Go live turns the key on once it passes.

  • Rendel asks the assistant three to five check questions drawn from your setup and needs at least 80% answered from your information or your app. A miss says why and where to fix it, the agent rewrites what fell short once, and check questions are not billed.

  • Run Sync with code and tell your agent what changed in a sentence. It brings Rendel level with your code, and on a live app every change waits in Sync review until your team applies it. Home also says when a build has something Rendel was not told about.

  • Yes. Your developers add the SDK by hand and fill each page through the console’s own forms, and the same five checks decide when you go live. If only outside calls are the concern, the setup file path has the agent send nothing anywhere.

  • Invite your developer by email when you create the app. They join as a Developer, who can set up the assistant but not see billing or manage the team, and your Home shows each step until the app goes live.

  • No. Setup, sync, the MCP server and the setup file are on every plan, including the $0 Pilot plan, and check questions are not billed. Once you are live, each answer Rendel writes counts as a message on your plan. Your coding agent’s own usage stays with its provider.

Related

Put it in your app this week.

Start free on your own, or tell us what your customers do most and we’ll show you that exact workflow, working, in a tailored demo.

  • PilotFree400 messages a month
  • Starter$199 / month4,000 messages a month
  • Growth$799 / month20,000 messages a month
Start with the PilotBook a Demo
Every plan, and the estimatorOr try a live store’s console first, yours for two hours

Prefer email?

sales@rendel.ai

Prefer to write first?

Tell us about your app and we’ll show the right workflow in a tailored demo.

Help us tailor the demoOptional

We use this to get in touch about the demo and, if a partner introduced you, to credit them. We never sell it. See the privacy policy.