Your QA department that runs itself and signs the evidence
TecnicaiT validates your software against your own operating procedures, every release, with no engineer babysitting it. Bounded by design, with a signed audit trail an evaluator accepts as evidence.
- Signed evidence per run, with per-step screenshots
- Its own guardrail: it cannot go off-script
- Bring your own key (BYOK): your AI cost, measured per run
Same models. Different guardrail.
A generic AI can test your app if you prompt it well. What it cannot do is make that repeatable, bounded, signed and operable by someone who is not a prompt engineer. It is the same gap as "a developer can run the tests by hand" versus "having CI": nobody certifies software with "one person tried it in their terminal". A guardrail is not what stops the AI from doing harm: it is what makes its work worth something.
A generic AI is a brilliant engineer you have to sit next to every single time. TecnicaiT is the QA department that runs your certifiable procedure on its own, every release, and leaves you the signed evidence.
From procedure to a mergeable PR
Your procedure as a contract
You load your versioned SOPs (operating procedures). TecnicaiT runs them the way your real users do: through the browser, with semantic selectors, with multiple roles coordinating with each other.
Validation bounded by construction
A closed action vocabulary, protected paths in two layers and hard budgets per procedure. The system has no capability to go off-script; it does not merely promise to behave.
It closes the loop to the merge
When it finds a defect it proposes a fix, gates it behind a mandatory test run, and produces a PR with the finding, the signed evidence and green tests.
Evidence an evaluator accepts
Every run produces a cryptographically signed audit trail, with signed per-step screenshots, tied to the versioned procedure. Material for a certification file, not a chat transcript.
A guardrail does not slow the AI down. It is what lets it move fast.
Your team already writes code with AI. Verifying it is the new bottleneck.
Producing is no longer the problem. Nobody reviews by hand, release after release, everything an AI writes in a week. TecnicaiT is the guardrail for that code: it runs your procedures against the real application, contrasts what it sees with the code and the data, and leaves you signed evidence of what was validated and what was not.
And to be able to leave it working on its own, the first thing we had to frame was our own AI.
A guardrail is not on the road to make you drive slowly: it is there so you can take the curve at speed. The same goes for AI. With no limits, a model needs someone sitting next to it judging every step, and that is where the time and the money go. The TecnicaiT guardrail is the frame around the AI on every run: what it can do, where, on what budget, and what evidence it must produce to back up any claim. Framed that way, the AI needs nobody watching: it is more accurate, because it cannot make claims without evidence, and it costs less, because routine work runs on the small model and the large one only steps in when the guardrail detects it is needed.
More accurate
- It cannot make claims without evidence Before touching anything, every finding is contrasted against the real contents of the file and against the captured screen. Whatever does not hold up is discarded with its reason, and the reason is kept.
- It does not mistake its own blind spot for a defect If the system did not find something, that is no proof it is missing. A deterministic rule downgrades it to human review before it can ever propose a change.
- It cannot break what already worked No fix is ever proposed without passing your own project test suite. If a new regression shows up, the change is reverted.
- It does not go around in circles When it insists on something that is not making progress, the system blocks it and forces a decision. A dead end becomes a finding with its reason, never an infinite loop.
It costs less
- The expensive model only steps in when needed Every task runs on the model at its level. The system escalates to the large model when it detects the small one is stuck, not by default.
- What can be checked without AI does not spend AI Interface language, table arithmetic, impossible values, comparison between releases: deterministic checks, zero model spend.
- It does not rediscover the same thing Memory across runs and per-file cooling: the catalogue moves forward instead of repeating itself.
- A closed budget per procedure Limits on actions, spend and time. Hitting them triggers a controlled stop. And every run tells you what it cost, in cents.
And the guardrail is measured: the system keeps count of how many times it had to escalate to the large model, how many findings its own self-critique discarded and how many the verifier refuted. When a safeguard stops paying off, it shows up in the numbers.
Three sources of truth that watch each other
Some defects never show up in code tests: a total that is not the sum of its parts, an impossible percentage, a state that contradicts the data. TecnicaiT captures and signs every screen, and judges it with three independent signals: the code (its tests), the data (the signed backend ledger) and the image itself. When all three agree, you get signed positive evidence; when they diverge, you get a finding with the priority it deserves.
You can start even without written procedures
Most teams do not have their operations documented as executable procedures. TecnicaiT does not ask you to start there: it proposes them for you.
It reads your repository and walks your app
It analyzes the code, the existing end-to-end tests, and performs an authenticated walk of the real application to understand which operations need validating.
It proposes a procedure catalog from your domain
It generates SOP candidates grounded in your actual business operations (not generic ones), citing the on-screen evidence each one is based on. Your team reviews and approves.
Every draft is validated by running it
Before entering the catalog, each procedure is executed against the live application and rewritten with the feedback from its own run. What remains is executable, not theory.
The catalog never falls behind
When your application evolves and a procedure stops reflecting it, the supervisors detect it and the system offers to regenerate it with the feedback from its real run. Always as a new draft version: approval stays with your team.
The engine is genuinely generic
The same engine, without a single line of client-specific code, validated end to end on four stacks that could not be more different. Everything that changes between them lives in configuration. The fourth stack is us: TecnicaiT validates itself every release.
| Pilot (energy) | Second client (industrial) | Third client (agrotech) | TecnicaiT itself | |
|---|---|---|---|---|
| Frontend | SvelteKit / Svelte 5 | Next.js / React 19 | React 18 / Vite / React Router | SvelteKit / Svelte 5 |
| Backend & auth | Static SPA, in-browser session | Laravel + Filament, Bearer token | Express + Prisma, token in client state | Node + Postgres, email/password session |
| What was validated | Catalog, multi-role execution and improvement loop with PR | Catalog, 9/10 execution and backend traceability | Catalog via authenticated walk and 8/8 step driving | The product validates itself: signed screens and triple contrast every pass |
It integrates like the rest of your bots
When it finds a defect and validates the fix, it delivers it as a Pull Request. No more and no less than what your dependency or code-quality tools already do.
It opens Pull Requests, it never touches your main branch
Every validated improvement arrives as a PR your team reviews and decides on. It never pushes to your main branch or merges for you; the proposal branch is ephemeral.
Your controls stay intact
Your branch protection, your reviewers and your merge rules apply exactly as with any contribution. TecnicaiT proposes; your team decides.
Minimal permissions
Only what it takes to open Pull Requests on the repository you connect. It does not ask for organization administration or access beyond that.
For the most demanding environments
If your policy forbids third parties writing anything to your repositories, the enterprise line delivers the change as a reviewable patch, without creating a single branch.
Do you validate software in a regulated sector?
Try it against your own software: each run costs pennies and leaves you the signed evidence an evaluator accepts.
Try it for pennies