Case studies: AI adoption, automation and software

Aircraft parts procurement: from email to a managed pipeline

An AI agent reads incoming RFQs, compares supplier quotes and checks trace documents. A separate deal-tracking system moves each deal through mandatory stages.

Full loop

the AI loop ran end to end on a live procurement process, from an incoming RFQ to a team notification. This was a pilot and the figures are our own so far: the client has not confirmed them yet

3

types of trace documents checked by the agent: FAA 8130-3, EASA Form 1 and COC. Like the figure above, it still awaits the client’s confirmation

A sales and support platform for a distributed partner network

Partners ask who on their team is inactive and what blocks the next level, and get numbers for their own part of the network only. Access is enforced at the SQL level.

Their own slice

a partner gets figures for their own team only: a filter on the current user is added to every SQL query

6 layers

of data protection between the language model and the database, from blocked personal-data columns in SQL to rate limits; counted in the code

Panel specs from CAD drawings in seconds, not hours

Reads DWG/DXF layouts and builds the Excel spec: 10–⁠30 seconds instead of 2–⁠15 hours by hand. All 784 panels of one real project matched the manual spec line by line.

784/784 and 189/189

panels on one project and wall panels on another matched the manual specs line by line, size groups included; area within 0.001 m²

2–15 h → 10–30 s

to produce a project spec: manual work vs app processing, measured on real projects

Profit per SKU across three marketplaces, checked against manual figures

Five seller accounts on WB, Ozon and Yandex Market merged into one SKU-level P&L. Variance from the client’s manual figures on a control SKU for one month: 0.00%.

0.00%

variance vs the client’s manual benchmark across units, revenue, COGS, profit and margin for a control SKU over a month; the threshold was 1%

1.18M rows

of sales across 5 accounts and 12 months processed; 10.7% were ordered and settled in different months

Land-plot marketplace with a next-step plan: MVP in 2 months

From a mock-up to a working platform: plot → works → contractor → request. Rule-based next-step engine, three dashboards, personal-data compliance. MVP in 2 months.

2 months

from approved spec to a pre-release MVP on an HTTPS stand: week 9 against the plan’s own 10–13 week estimate

7 days

from spec to the first full-implementation commit: 168 files, 21.5k lines, then two months of hardening to pre-release

Rule-based repricing: a pilot whose contract terms are enforced in code

Competitor prices tracked per SKU, a price computed by rules inside an agreed corridor and applied only after confirmation. Pilot: 10 SKUs, setup within 14 days.

10 SKUs · 2 scenarios

pilot scope; the SKU cap and both scenarios are enforced in code and verified by contract tests, so the cap cannot be exceeded

up to 14 days

contractual setup window from client inputs to launch, then a 1-month pilot; the service tracks the dates and closes access when the period ends

From business canvas to a student-work marketplace demo in about six weeks

The client had a business model and no product. We built a student-task marketplace MVP where the server enforces legal and platform rules, and put a demo stand live.

~6 weeks

from first commit to a deployed demo with all workspaces; 7 working days in commit history

3 checks

run by the server before a contractor is assigned: data consent, self-employed status, mentor; each with a plain refusal

Agent teams assembled from configuration, with paired critic agents

The core of a multi-agent platform in 2.5 weeks: 29 declarative agents in three teams, agent-critic pairs, shared memory on four databases, five autonomy levels.

25,000+

lines of Python in the platform core across 134 modules, counted from the repository

29

declarative agents in three ready-made teams (engineering, cognitive, research); counted from YAML specs

A multi-agent environment where the rules are code

In four days we built and open-sourced (MIT) an agent environment where code enforces the rules: cryptography, a PBFT-style agreement protocol, reproducible experiments.

same hash

a repeated run and a replay of the log give a byte-identical final event hash; anyone can check it on the MIT-licensed code

187 of 187

engine tests passing; master branch, commit 625b81d, as of 05.10.2026

Long-term student memory: from hypothesis to a working service

A research neuromorphic memory core and a student model, taken to a service in 10 days: 32 REST endpoints, 368 tests, 21 Lean 4 statements. The code is open.

10 days

from first commit to a release with formal verification, measured by commit dates

368

test functions across 37 files, counted from code

From mathematical theory to a verified numerical library in 9 months

Compensated-computation library: precision loss is visible and checkable, the model’s algebra is proved in Lean 4, each numeric claim has a reproducible benchmark.

1.0 instead of 0.0

residual preserved on the [1e16, 1, −1e16] sum that float silently drops; reproducible benchmark generated by a script in the repository

6 of 6

scenarios of the published benchmark in which the exact dot-product kernel matched the exact reference; numpy.dot matched in 0 of 6. The C kernel is not yet released on PyPI, and the cancellation scenario was built on purpose

A mobile client for an AI learning platform, built without waiting on the backend

Flutter client for an exam-prep platform: adaptive micro-lessons, a streaming AI assistant, a knowledge map. The UI was built alongside the backend via a mock layer.

13 weeks

from first commit to a working app with sign-in, goals, lessons and AI chat

41 → 81 endpoints

API coverage doubled from MVP to the extended version, with 14 → 31 modules on the same architecture

A pilot plan for the visitor, a qualified lead for sales

We replaced the contact form with an AI consultant: it interviews the visitor, returns a pilot plan with KPIs and risks, and sales gets a lead with budget and timeline.

1 day

to build a working MVP: frontend, backend and deploy configs

16 days

from first commit to production with HTTPS and an issued certificate on its own domain

StudyNinja and KnowledgeBaseAI

The learning platform and the graph knowledge platform are covered in the Ecosystem section.