> For the complete documentation index, see [llms.txt](https://docs.servoy.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.servoy.com/reference/servoyai.md).

# ServoyAI

ServoyAI: the AI coding agent built into Servoy Developer. Set it up, learn the /svy commands, and understand its spec-driven, review-gated agent workflow.

## What is ServoyAI?

ServoyAI is an AI coding agent that lives inside Servoy Developer. You describe a change in plain language, and it works through your solution the way a senior developer would: it reads the ticket, the API and your Git history, writes a spec, and only starts coding once you approve that spec.

It is not a generic chat assistant bolted onto the IDE. It runs as a small team of specialized agents coordinated by an orchestrator, and it knows the current Servoy surface: the one current client (Titanium NG), the scripting API, foundsets, forms, security, and your solution's own conventions. That product knowledge is what lets it build real changes instead of plausible-looking code you have to rewrite.

## Two things make it different

**No model picker.** You do not choose a provider or a model. ServoyAI ships with one model and connects to it for you, so every session behaves the same way for everyone on the team. There is no provider screen to configure and no key to set by hand — access runs through a ServoyAI plan and a developer seat on your Servoy Cloud namespace.

**It forces a spec-driven flow.** On anything bigger than a one-liner, ServoyAI writes a spec before it writes code, summarizes it, and stops. Nothing is implemented until you answer. This is deliberate: the cheapest moment to catch a wrong assumption is before any code exists, and the spec is where a silently-decided approach or test strategy becomes visible. You read it, correct it if the root cause is wrong, and then it proceeds. The full sequence is below under [The flow, start to finish](#the-flow-start-to-finish).

## How the agent team works

ServoyAI is not a single model answering prompts. One orchestrator turns your request into acceptance criteria and hands each part of the work to the agent that owns it. You talk only to the orchestrator; it coordinates the rest.

| Agent             | What it does                                                                                                                             |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Orchestrator      | The team lead. Turns your request into acceptance criteria, writes the spec, dispatches the other agents, and holds the approval gates.  |
| Researcher        | Finds the facts the orchestrator needs — API behavior, module ownership, existing patterns — and reports them without deciding anything. |
| Developer         | The senior developer. Builds the change and owns how it is built.                                                                        |
| Reviewer          | Peer-reviews the Developer's work. Runs after any agent that produces code.                                                              |
| JSUnit-Tester     | Writes JSUnit tests for server-side logic, once testing is in scope.                                                                     |
| E2E-Tester        | Writes Cypress end-to-end tests for user flows across forms, once testing is in scope.                                                   |
| Security-Reviewer | Checks anything that reaches outside Servoy: external APIs, credentials, tenant isolation, injection.                                    |

## The flow, start to finish

For a reliable run, start with a [`/svy` command](https://docs.servoy.com/reference/servoyai/commands.md). A command routes your request straight to the right path with the right rules already loaded, so the same kind of task behaves the same way every time; plain free text works too, but then the orchestrator has to guess which path you meant. Either way, for anything new or a larger change the ServoyAI orchestrator runs the same sequence:

1. **Analyze.** It reads the ticket or the input you gave it and turns that into acceptance criteria.
2. **Spec and stop.** It writes a spec and hands it back to you. Nothing is built yet — you review it and say go.
3. **Choose the tests.** The spec includes a test strategy, and whether to write JSUnit tests, end-to-end tests, both, or neither is your call. The orchestrator asks; it never decides this for you. You answer at the same moment you approve the spec.
4. **Build and review.** Only now does the development loop start: the Developer implements, the tester writes the tests you asked for, and the Reviewer checks the work. Findings are routed back and fixed until the review passes.
5. **Commit.** When the review passes with every acceptance criterion evidenced, the agent offers a commit. It never commits without your go.

A small, structural change can take a faster path, but the two gates never move: you approve the spec before anything is built, and you approve the commit before anything is saved.

## Where to go next

* [Setup](https://docs.servoy.com/reference/servoyai/setup.md) — the plan and seats an admin assigns in Servoy Cloud, then logging in on the developer side.
* [Commands](https://docs.servoy.com/reference/servoyai/commands.md) — the `/svy` commands and what each one routes to.
* [Configure the agents](https://docs.servoy.com/reference/servoyai/configure.md) — the `AGENTS.md` that tells the agents how your project is wired.
* [Working with ServoyAI](https://docs.servoy.com/reference/servoyai/working-with-servoyai.md) — habits that make it reliable: one session per task, reading the spec, and knowing when to interrupt.

## Building AI into your own app

ServoyAI helps you *build* your solution. It is separate from the AI you put *inside* that solution for your end users — a chatbot, a document classifier, a natural-language search over your data. You build those with the [AI Plugin](https://docs.servoy.com/guides/develop/programming-guide/building-ai-features.md), which calls language models from your server-side code.

Those models have to run somewhere, and you do not have to arrange that yourself. [Private AI Hosting](https://docs.servoy.com/reference/servoy-cloud/cloud-control-center/add-ons.md#private-ai-hosting) in Servoy Cloud runs the GPT family, Claude and open models on Servoy's own infrastructure. You call them straight from the AI Plugin with a base URL and a token — no provider accounts to set up, no API keys to manage across vendors, and no GPU infrastructure to run. Your data stays inside the Servoy Cloud boundary, and each model shows its region in the catalog: most run in the EU, while some are offered only globally, such as the OpenAI models. It is pay-as-you-go from a prepaid credit balance, billed in one place with the rest of your Cloud usage.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.servoy.com/reference/servoyai.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
