The work nobody wants to do
Every team has a task it keeps postponing. In large Ruby on Rails codebases, that task is writing tests. Feature work always comes first, untested code piles up, and teams end up spending more and more time chasing painful bugs.
In a recent article titled Rails testing on autopilot: Building an agent that writes what developers won't (Mistral AI, March 11, 2026, by Maxime Langelier and Mathis Grosmaitre of the Applied AI Proto team), Mistral describes how it closed that gap. It built an autonomous agent that reads Rails source files, writes or improves RSpec tests, checks them against style rules and coverage targets, and runs inside a CI/CD pipeline without human intervention.
If you build AI agents on n8n, Make.com or Zapier, you have your own version of this problem. You can design a strong workflow with good prompts, the right tools and clean logic. Then you hit the task nobody wants to do: building the interface people will use to talk to your agent.
This article covers what Mistral's experiment teaches about building reliable agents, and why a reliable agent still fails if nobody can reach it. That second part is where Chat4Agent comes in.
Five lessons from an agent that had to work at scale
Mistral's agent was not a demo. It processed a real repository of 275 source files. Half had tests and half had none. Here is what made it work.
1. Context beats cleverness
The team built the agent on Vibe, Mistral's open-source coding assistant, and kept the default system prompt. Most of their effort went into context engineering. A repository-level file called AGENTS.md is appended automatically to the system prompt. It gave the agent a step-by-step execution plan with success criteria for each step.
That single Markdown file raised the quality score from 0.68 to 0.74. They changed no model and wrote no complex code. They only gave clearer instructions.
2. Specialize instead of generalizing
Rails apps contain several file types, including models, serializers, controllers, mailers and helpers, and each needs different tests. One generic skill gave mediocre results, because instructions that fit a model file are wrong for a controller. The fix was a separate skill file for each category, plus one for plain Ruby files.
3. Force a self-review
The agent sometimes produced specs that looked complete but quietly skipped public methods. So the instructions end with a mandatory check: re-read the source file and ask, did I test every public method? Count them. If anything is missing, the agent goes back.
4. Give the agent tools that tell the truth
Two custom tools mattered most. A RuboCop linting tool caught style violations so the agent could fix them. A SimpleCov tool, run together with RSpec, executed every test and reported which ones failed and which lines of code were never exercised.
The numbers are worth noting. When this tool was first added, only about a third of generated tests passed on first execution. The agent fixed every failure within a few iterations. In the final experiment, 100% of tests passed and coverage reached 100%.
5. Looking good is not the same as working
The team also used LLM-as-a-judge, asking a model to score each test from 0 to 1 against clear criteria. It is a useful aggregate signal: across tested files, the score rose from 0.49 to 0.74. By file type, models scored 0.81, serializers 0.80 and controllers 0.67.
They also found a trap they call the missing parenthesis problem. One test was well structured and readable and scored an average of 0.75 across several models. It would not run at all, because a closing parenthesis was missing. The judge could not see what only execution could reveal.
Their conclusion was that making the agent actually run everything it wrote was the most impactful decision of the project.
The question every agent builder should ask: does it run?
That last lesson goes well beyond Rails testing.
A test that looks perfect but never executes is worthless. An agent that works perfectly but that no one can use is worthless too.
Mistral's agent runs headless in a CI/CD pipeline, so its users are other machines and that setup fits. Most agents built by no-coders, developers and agencies are different. They serve people: a customer asking about an order, a sales rep qualifying a lead, an employee searching internal docs, a client testing the assistant your agency delivered.
For those agents, "does it run?" really means:
- Can a non-technical user open it and start a conversation right away?
- Does it look professional enough to put in front of a customer?
- Can you deploy it today, or does it sit behind a webhook only you know how to trigger?
If the answer is no, the agent has the same problem as the missing parenthesis. It scores well in your head and fails in the real world.
What happens when you skip the interface
The usual workarounds have real costs.
For no-coders, the agent often lives inside a scenario editor or a form tool. You test it yourself, it works, and then you realize you have no clean way to share it. Users get a clunky form, a raw webhook URL or nothing. Adoption stalls, and the time you spent on the workflow is wasted.
For developers, building a chat front-end means handling message display, conversation state, connection to the workflow, styling and hosting. None of that is your agent's actual value. It is the work you keep postponing, just like Rails tests, and every week spent on it is a week without users.
For agencies, the interface is what the client sees. You can deliver an excellent n8n or Make workflow, but if the client receives something that looks unfinished, they judge the whole project by it. Building a custom front-end for each client cuts your margin and slows delivery.
In all three cases you end up with a capable agent and a bad experience around it.
Chat4Agent: the interface you won't build
Mistral built an agent to write the tests developers won't write. Chat4Agent applies the same idea to the layer agent builders won't build: it gives your AI agents a professional chat interface, with no technical skills required.
You keep building your agent where you already work, in Make.com, n8n, Zapier or similar platforms. Chat4Agent adds the conversational front-end that turns your workflow into something people can use.
Here is how it maps to the lessons above.
Keep your effort on what matters
Mistral's team kept the default system prompt and spent its energy on context, skills and tools, the parts that raised quality. Chat4Agent lets you work the same way. You put your effort into your agent's logic, prompts and integrations, and the interface is handled for you.
Specialize each agent, and give each one its own interface
One generic skill could not test every file type well. One generic interface does not suit every agent either. A support assistant, an internal knowledge bot and a lead qualification agent serve different audiences. With Chat4Agent the interface is customizable, so each agent can present itself in a way that fits its purpose and its users.
Test with real conversations, not assumptions
The key insight in the source is that execution reveals what appearance hides. A chat interface gives you the same benefit for agents built for humans. Once your agent sits behind a real interface, you and your users can talk to it, see where it struggles and refine your workflow. You stop guessing how it behaves and start watching it work.
Deploy immediately
Mistral's agent is useful because it runs automatically in a real pipeline. Your agent is useful when it is available to the people it serves. Chat4Agent is built to make your agent immediately deployable, so you do not need a separate front-end project before launch.
Before and after: three typical scenarios
The no-code entrepreneur
- Before: A well-built n8n agent answers product questions, but only the founder can trigger it. Customers never see it.
- After: The same workflow, connected to a Chat4Agent interface, becomes a customer-facing assistant without any code.
The developer
- Before: The agent logic is done in a few days. Then the developer spends extra time building and maintaining a chat UI, and the launch slips.
- After: The developer connects the agent to Chat4Agent and ships, then spends the saved time improving the agent with the kind of context engineering and tool design Mistral describes.
The agency
- Before: Each client project needs a custom front-end. Delivery is slow, margins are thin and quality varies.
- After: The agency builds agents on the automation platforms it already knows and delivers each one with a professional, customizable interface. It becomes a repeatable service it can offer every client.
A practical checklist for your next agent
These principles come from Mistral's experiment and apply to any agent you build:
- Write a clear execution plan into your agent's instructions, with success criteria for each step.
- Specialize your prompts or sub-agents by task instead of relying on one generic instruction set.
- Add a self-review step so the agent checks its own output before answering.
- Connect tools that return real results, not just the model's opinion of itself.
- Do not trust appearance alone. Scores and demos can look great and still hide failures.
- Make sure it runs for real users. Put your agent behind an interface people can actually use, which is what Chat4Agent is for.
The first five steps make your agent reliable. The sixth makes it useful.
Why this matters now
Mistral's experiment shows that a model alone is not enough. Clear context, specialized instructions, verification tools and a real-world check turn a promising agent into one that works. Their aggregate test quality went from 0.49 to 0.74 and every test ran, because they refused to stop at "it looks good."
The same applies to your agents. Building the workflow is the first half of the job. The second half is putting it in front of the people who need it, in a form they will use and trust. Agents that never get that interface stay internal experiments. Agents that get it start delivering value.
Give your agent the interface it deserves
You have already done the hard part by building an agent that works. Don't let it sit unused behind a webhook.
Try Chat4Agent for free, with no credit card required, and connect your Make.com, n8n or Zapier agent to a professional chat interface in about 2 minutes. Your agent is ready to work, and Chat4Agent makes sure people can use it.
Source: Rails testing on autopilot: Building an agent that writes what developers won't | Mistral AI