October 9, 2026 in platform, agents by Primael Azinnongbe, Marc Fawaz and Dimitri Tombroff8 minutes
Synthia capitalizes on a team's documents with AI. Its first module generates quizzes that an agent can edit, rework and reshape, in the application or in a conversation: an agentic platform and a business application built to meet.
Synthia is a Fred application for capitalizing on a team’s documents: turning what is written in them into something people can learn from, check and reuse. Its first module, Synthia Quiz, generates quizzes from those documents. Mind maps and slide decks are planned next, on the same foundations: the application already stores every generation the same way, whatever it produces.
What makes Synthia Quiz worth writing about is not the quizzes themselves, but how it was built: an ordinary business application on one side, an agent on the other, and Fred in between. The agent does the writing, the application keeps the result reliable, and the person moves freely between the two.
That is the point we want to make. Fred is an agentic platform strong enough to combine an agentic system with a business application, and its structure makes the bridge between agents and applications a first-class thing. Synthia Quiz is a telling example.
Teams need to check that their members master what they are supposed to know: a procedure, a specification, a regulation, the content of a training. Quizzes are a simple way to do it, but writing good ones takes time, and they go stale as soon as the documents change.
Synthia Quiz lets a team build those quizzes from its own documents, the ones already in Fred. Every question comes with its source: the passage it was drawn from, and the document and page it sits on. A collaborator who takes the quiz is measured against what the documents actually say, not against what a model happens to believe, and can open the source when an answer surprises them.
The next step, under way, is to close the loop for the person who launched the quiz: summary dashboards on how the audience did, and a synthesis of the points to review, proposed by the AI from the questions most often missed.
Any agent or language model will happily write quiz questions. Two things are missing.
A single, integrated place. The quizzes, their sources, the people taking them and the results belong in one application, inside the platform where the documents already live, not scattered across chat transcripts.
Reliability. Left to itself, a model writes questions easily, but it does not hold a requested number, it invents sources, and it does not say when a document is not enough. Passing the parameters through the prompt is fragile: the quiz agent Synthia Quiz replaced was asked for thirty questions and returned fifty-four.
Three pieces belong to Synthia: a web interface, an API, and an agent running in its own pod. Everything else, from sign-in and permissions to documents and conversations, comes from Fred.

Synthia inside Fred: the team’s quizzes, next to Fred’s own menus and conversations.
%%{init: {'theme':'neutral','flowchart':{'curve':'basis','htmlLabels':true,'nodeSpacing':45,'rankSpacing':55}}}%%
flowchart LR
P(["Person"])
subgraph FRED["Fred"]
UI["Synthia's interface
(an iframe in Fred)"]
CHAT["Fred's chat"]
KF["Knowledge Flow
documents, search, spreadsheets"]
SEC["Keycloak · OpenFGA
identity · permissions"]
end
API["Synthia API
quizzes · rules"]
AG["Quiz agent
(its own pod)"]
LLM(["Language model"])
P --> UI
P --> CHAT
UI -- "requests relayed by Fred" --> API
API -- "starts" --> AG
CHAT --> AG
AG -- "MCP tools" --> API
AG -- "search · SQL" --> KF
AG --> LLM
API -. "checks every call" .-> SEC
classDef syn fill:#e6e9fb,stroke:#3346c4,color:#171a26;
class UI,API,AG syn;
The agent owns no data. Everything it writes goes through the application’s tools, and the tools hold the rules:
In Synthia, the person picks documents, a difficulty and a number of questions, then clicks Generate.

The new quiz form: a folder, the documents (a spreadsheet is read through its tables), the difficulty and the number of questions.
The API starts the agent itself, and holds its stream: the tab can be closed, the generation goes on. A panel beside the library follows the agent’s work, from the names of the tools it calls, never their content.

The agent at work: the panel beside the library follows its stages.
At the end, the panel says how many questions are ready, and why there are fewer when the documents did not cover the request.
Fred makes this possible without giving the application the person’s token. The application’s page never holds one: Fred attaches it to the requests it relays. Once the agent is running, Fred’s delegation lets it speak for the person with a token of its own, renewable, while every call is still checked against the person’s own rights.
The same agent is available in Fred’s chat, where it can do far more than generate:

When several quizzes fit, the agent asks which one, with the candidates as choices, through Fred’s question tool.

The quiz shown beside the chat, read-only, with the links back to Synthia.

Before a quiz is deleted, Fred asks the person: the tool runs only once they accept.
Collaborators take the quiz in Synthia: one question at a time, with the explanation and its source after each answer, then a score. Every source opens in Fred’s own document viewer, at the page it quotes.

Practice mode: the answer, the explanation and the quoted source, with a link to the page in the document.

The score, question by question.
Screenshots from a test deployment. The interface is in English; the questions follow the language of the documents, here French.
Not novel: generating questions from retrieved passages is ordinary RAG, and the agent is a standard ReAct agent from Fred’s SDK. We did not invent a new way to write questions.
What is worth a closer look:
What we learned the hard way: instructions are not guarantees. Two real incidents during testing:
The pattern is the same each time: what must always hold belongs in the application’s code, and the prompt only says how to work well within it.