What is this product and why is there no LLM in the runtime?
With the client’s permission, I’ll briefly explain the project—just for clarity. On a password-protected Tilda page, there is an internal form. The specialist selects the areas: money;love;health;protection;harmony;energy;career;confidence;luck; family; development.
Then they select the product design: women’s, men’s, or unisex. In response, they receive up to five cards: a name, a composition description, and tags.
The cards are drawn from a PostgreSQL table containing 1,684 records. These are the author’s “recipes” for stone products: each product is described by a combination of minerals and properties specified in the master’s source document. For example: “rhodonite — love, family, tenderness; sunstone — courage, determination.” The properties themselves are content of the author’s catalog, rather than something subject to technical verification.
The tool is not public. It helps the specialist obtain, within seconds, a quick-reference sheet for the client’s request instead of manually searching and typing out the text.
The first thing that came to mind was to put an LLM between the form and the database so that it would “understand the request.” I rejected this for three practical reasons:
1. Latency. Searching across 1,684 rows does not require a separate network call to the model.
2. Cost and variability. The model would add costs to every request and change the behavior in cases where the search rules can be written explicitly.
3. Source of truth. SQL returns specific records from the catalog.The model could add a plausible property or explanation that is not present in the source.
SQL does not make the original descriptions any truer or verify their meaning. It simply does not layer any newly generated claims on top of them. Therefore, an ordinary query remains at runtime, while the LLMs operate only during the development stage.
Division of roles between the models
The “hands” —particle-1. This model ran in Cline and handled the bulk of the mechanical work: it wrote SQL and JavaScript, changed expressions, corrected field names and quotation marks, and suggested the next iteration after an error.
The “brain” —gpt-6-luna-pro. I brought it in selectively: to work through PostgreSQL array handling, to shift the frame when there was an issue with the webhook response, and to discuss the final solution in general.
The practical cycle looked like this:
1. I gave the model the contract and the current snippet.
2. The model suggested code or a patch.
3. I applied the change and ran the workflow in n8n.
4. The error text, OUTPUT node, or incorrect result was returned for the next round.
5. If the problem was syntactic, the “hands” continued.If the diagnosis itself needed to be reviewed, the “brain” was brought in.
I did not delegate executions, verification of the actual HTTP response, or product decisions to the models.
Why I focused on latency rather than just price
At the time of my measurement, the OpenRouter comparison page showed the following values:
This is a screenshot of a specific page on a specific date, not guaranteed model specifications for the future. OpenRouter metrics depend on the provider, the measurement period, and request conditions. In addition, p50 on such a page does not equal the duration of the full Cline cycle: it also includes applying the patch, tool calls, launching the workflow, and reading the result.
But as a guide for choosing a role, this difference worked for me. When an agent makes a series of small edits, I need to get the next iteration quickly. Higher throughput is useful for long generation, but by itself does not speed up the start of the response.
Subjectively speaking, Particle-1 made it possible to conduct mechanical debugging at a more comfortable pace = fewer pauses between “got an error” and “try the next option”. This case does not imply that its full agentic cycle was always five times faster—I did not conduct such a measurement.
The costs were also modest. One Particle-1 session shown in the first screenshot cost 0.49 monetary units. A session involving GPT-6 Luna Pro cost approximately 0.04 monetary units. But these were sessions of different sizes and purposes, so they cannot be compared as the cost of solving the same task.I’m not reflecting the total cost of the entire development in these two figures.
What specification did the “hands” receive
The task was formulated not as “write me...,” but as a constrained specification:
input: POST body {spheres, gender};
- TAG100@@output: up to five rows {id, name, full_recipe_text, tags};
filter records by tag overlap;
- TAG108@@sort by the number of matches;
- TAG112@@when scores are equal, rank an exact field match above a universal match, then prefer a narrower list of tags;
- TAG116@@limit the result to five records;
- TAG120@@do not use an LLM at runtime;
- TAG124@@do not invent columns or change the meaning of existing fields;
- TAG128@@construct the query so that the current n8n–PostgreSQL combination accepts it.
TAG136@@What was built in n8n
The entire search pipeline consisted of four n8n nodes:
TAG142@@Successful runs and the workflow itself
