More ideas than IT capacity.
Survey of 307 CIOs, CTOs and CISOs: Wynter for Retool, June 2026.
Development has to get several times faster, not a few dozen percent.
AI already writes code. To make projects noticeably faster and cheaper, the process itself has to change.
You can test an idea in an evening. But every next change can break what already worked, and no one maintains the system or owns the risks.
The team and the process stay the same. Individual tasks get faster, the project as a whole does not. Meanwhile token costs grow with the codebase, and assistant vendors are moving from flat subscriptions to usage-based billing.
The application is described by a model. It is easier to change than thousands of lines of code, so changes ship faster and cost less, and each one passes the platform's checks.
Agents carry out multi-step tasks directly in code and are indispensable in complex systems. They need a mature engineering environment with tests, environments, automated builds and security controls, built and run by engineers.
Data on AI assistant gains: GitHub, 2023 — +55.8% on a lab task; Google, 2024 — about 21%; METR, 2025 — experienced developers were 19% slower on their own tasks. Move to usage-based billing: GitHub Copilot, 2026.
With Arci, the business gets the speed of AI development, and IT gets control over security, audit and support.
A small team decides what comes first and owns the result. Each product has its own team, and teams work in parallel.
Engineers evolve complex systems and non-standard integrations, and run security and operations for the platform and every application on it.
From idea to production.
The application is described by a model, and the platform runs it. AI agents help the team build the application; in production it runs without calls to AI.
Example: a request system for a bank
Goal: collect requests from all channels in one place and pass them to sales faster
Acceptance: duplicates are removed, every request reaches the contact centre or a salesperson
Channels: website, app, branches, partners
Rules: remove duplicates, score, check restrictions
Participants: contact centre, sales
Entities: request, client, channel
Process: new → review → handed over
Screens: register, request card
Roles and permissions: a salesperson sees their own requests
Integrations: website, app, partners
- № 1024 · websiteNew
- № 1025 · partnerReview
- № 1026 · branchHanded over
- № 1027 · websiteNew
- 01IdeaProduct owner
Defines what the business needs and how to check the result.
- 02Business requirementsAnalyst
Describes the process: participants, rules, links to systems.
- 03ModellingAnalyst and AI agents
AI agents turn the description into the application model, and the platform checks it.
- 04ExecutionPlatform
The model runs on the platform.
Engineering culture, out of the box.
Arci takes care of the engineering part of the application and checks every change. The team focuses on business value.
More than half of the application is provided by the platform.
This is how a request travels through the application. In every part the team writes a description, not code. The platform does the rest.
- Description — written by the team and AI agents
- Platform — ready-made code shared by all applications
- Outside — stays as it is
Roles and permissionsSign-in and usersPermission check on every requestPersonal data maskingAudit and logSettings and feature flagsInterface languagesSystem passport
Build and releaseCluster and scalingMonitoring and logs
StackJava 25Spring Boot 4Apache CamelOAuth2 / OIDCOpenTelemetryPrometheusMCPAndroidiOS
Outside
Links to the outside world
Interface User
API Partners
MCP AI agents
Integrations Your systems
AI gateway AI models
Logic and data
Business logic
Data Database
Roles and permissionsSign-in and usersPermission check on every requestPersonal data maskingAudit and logSettings and feature flagsInterface languagesSystem passport
Build and releaseCluster and scalingMonitoring and logs
StackJava 25Spring Boot 4Apache CamelOAuth2 / OIDCOpenTelemetryPrometheusMCPAndroidiOS
Where code is needed
- IntegrationsComplex adapters.
Standard adapters and mapping are configured in Arci. Only the most complex ones are written in code.
- Business logicComplex logic.
Heavy calculations and special logic are written in code, and the Arci application calls them through integrations.
- Your systemsEvolving your systems.
Arci works with the core system, processing, CRM and scoring through integrations, while the systems themselves evolve in code.
With Arci the team learns agentic development and applies that experience to tasks that need code.
Control lives in the core, not in the agent.
Your team makes changes together with AI agents, and the agents check every edit against Arci's rules themselves. Build and release go through the platform core: it sits outside the agent's reach, so its checks always run — a broken rule blocks the change or at least lands in the audit log.
On your sideyour team, AI agents and your infrastructure
Arci coreindependent of the agent and its environment
Your environment · your infrastructure
AI agentsClaude, Codex, Cursor and others
task → plan → change → self-checkAI models: cloud or local
Provided by Arci · runs in your environment
- Rulesrecipes, platform rules, prohibitions and policies, in the agent's context
- Checksmodel checks against the canon (permissions and roles, versions, references) and a screen linter, which the agent runs on every edit
- Agent managementeach agent has its own task, permissions and limits; a shared board
- Built on a pinned platform release: the manifest is verified by checksum
- A linter based on Arci rules, and unit tests
- SonarQube code analysis and a check of screen expressions
- Failed: the change goes back to the agent
- The built and checked release goes to the test environment
- Readiness check after start
- Release audit: what was released, where and when
- Any previous release can be deployed again
- An error stops the build.
At the very first build step the application model is checked against 50 rules and 131 schemas. If the model has an error, the build stops at once and shows the agent where it is.
- The change shows up in the test environment.
The change is applied in the test environment, so you see how the application has actually changed. Any inaccuracy in the model shows up at once.
- AI agents connect on the platform's terms.
An application publishes its processes as MCP tools for external AI agents: only what is published can be called, and every call is recorded in the audit log. The application calls AI models only through the platform's AI gateway and on its rules: allowed models and tools, personal data masking, budget and log.
Where Arci fits.
From a single task to the entire front office.
- MVPs and hypotheses
If the idea works, the same MVP grows into a production system, and the work carries on from where it is.
- Digitising routine work
Requests, registers, approvals and reconciliations move from Excel and email into convenient applications.
- Step-by-step modernisation
Functions move from the core system, ERP or CRM to Arci one at a time. The old system keeps running, while new capabilities appear on Arci.
- Unified front-office system
Web, mobile app, self-service kiosk and bot all run on one model. With conventional development, this is a multi-year programme.
The team you need depends on the scale of the task.
Dozens of users, one or two integrations.
Hundreds of users, mandatory audit.
Dozens of connected systems, roles and access, multi-step approvals, reporting.
Processing, billing, settlement and trading systems: millions of operations and strict speed requirements.
In agentic development, AI agents write the code under engineers' control. Such systems run alongside, and Arci connects to them through integrations.
part-timefaded — upper end of the estimate
A request processing system for a bank.
LMS (Lead Management System) collects the bank's requests from the website, the mobile app, branches and partners. It removes duplicates, enriches and scores each request, checks restrictions and hands it to the contact centre or a salesperson. An analyst and a product owner built it in 6 weeks; the core improvements needed along the way became part of the platform.
- 6
- weeks to go-live
- 2
- people: an analyst and a product owner
- 77
- entities in the model
- 21
- connected systems, 9 of them external
Start with one process.
Pick a task you have long wanted to solve. Your team builds it, while we train the team and take care of the platform.
How to fit it in: three ways
- Build from scratch
A new product or process that does not exist in any system yet.
- Embed into your landscape
A process that now lives in email, Excel and several systems. Screens open inside your systems, and the data stays with you.
- Carve functions out of legacy
Agents read the old code and build a description from it, then check the result against a copy of the data. The live system is not touched.
Pilot plan
What we need from you
A process owner and an analyst. An administrator and a security specialist will be needed for a few days.
What we provide
The platform, team training and second- and third-line support for the whole pilot.
From idea to change. You run the whole cycle.
The work moves to agents. Responsibility for the result stays with you.
- You
- Agents