A payments platform in production
Built with the product, from the code to what is running today. Real money goes through it.
Not code suggestions. Delivered work — under your rules.
Kodzonia studies your code, builds specialists and records every cost.
01 Request
The commission calculation is wrong when an order has a partial return.
02 Agent at work
03 Diff to approve
- commission = order.total * rate
+ commission = (order.total - returned) * rate
Tests passing
04 Cost on record
Illustrative example
Zonialabs is a member of the programLearn more
From a request in plain language to an approved diff — without you becoming the middleman who copies and pastes.
Illustrative demo: your request is not sent anywhere.
You type
The commission calculation is wrong when an order has a partial return. Investigate and fix it.
Searches the whole repository by meaning, not by text. It finds the four classes involved, including the one nobody remembered.
Builds the fix plan and shows it to you before touching any file.
Edits the files, runs the test suite in the terminal, reads the failure, fixes it and runs again.
Opens a full diff, the test log, and the exact token cost of that task.
Records the business rule it found as project memory: you confirm it, or it saves it directly. On the next task, it already knows.
You approve, or send it back.
Learn moreKodzonia wasn't tested on a sample project. It builds software that serves real people — and it built itself.
Built with the product, from the code to what is running today. Real money goes through it.
Zonialabs, the company behind Kodzonia, is a member of the program.
Any assistant's demo impresses. The pilot passes. Then it touches the system that pays the bills — and the conversation ends.
The system doesn't fit in context and has no tests. The assistant reads a piece, guesses the rest and breaks something else.
In Kodzonia: real code analysis, not text — the agent maps who calls what before proposing, and runs the suite after editing.
The endpoint only the old team understood, the field that changes per client. None of it is written down, so the model invents.
In Kodzonia: when information is missing, the agent asks instead of inventing — and the answer can become project memory.
Without a line per call, with model, tokens and duration, there is no management. There is a surprise on the bill.
In Kodzonia: every call recorded with cost, per task and per project. Spend becomes a number before month-end.
Every session starts from zero. Yesterday's decision doesn't survive, and the team has the same debate every week.
In Kodzonia: every decision stays in the project, with origin and version. The next task starts knowing what the last one learned.
None of the four is solved by a better model. They are solved by engineering.
Learn moreIt reads and edits files, runs commands, commits and checks it running.
Learn moreSpecialists come from what the project calls for. Destructive actions stay yours.
Learn moreDecisions and conventions stay in the project and already apply on the whole team's machines.
Learn more| Topic | Kodzonia | Typical assistant |
|---|---|---|
| Work | Executes: edits, runs, tests and commits | Suggests: you copy, paste and run |
| Cost per task | Every call on record, per task and per project | No line per call: a surprise on the bill |
| Memory | The next task starts knowing what the last one learned | Every session starts from zero |
| Permissions | You declare folders, tools and a brake on destructive actions | Depends on the tool |
| Isolation | Each project with its own runtime, scope and memory | Depends on the tool |
| Audit | Model, tokens, cost and duration of every call | Depends on the tool |
Before
You hunt for the files, copy snippets into the assistant, paste the answer, run the tests and come back with the error.
After
You write the request. It searches, plans, edits, runs the tests and shows the diff. You approve, or send it back.
| Feature | Code assistants | Cloud agents | Kodzonia |
|---|---|---|---|
| Governance | |||
| Rules enforced on the server | yesenterprise plans only | yesenterprise plans only | yesall plans |
| Roles and audit | yes | yes | yes |
| Human approval before actions | yes | partialreview on the PR | yesceiling set on the panel |
| Specialists with model, limits and budget | partialno per-agent budget | partialno per-agent budget | yesbudget per subagent |
| Cost management | |||
| Limits per person, specialist and request | partialuser or team only | partialenterprise plans only | yes4 layers on the panel |
| Your own AI account and credits on the same plan | partialin some products | not verified | yes |
| Built for Brazil | |||
| Billing in reais with a Brazilian invoice | no | no | yesexclusive |
| Product in Portuguese | partialvaries by product | not verified | yespanel and desktop |
| Project memory | |||
| Memory shared by the team, on the server | partialthrough a file in git | partialvaries by product | yesproject + personal |
| Reads the repository and writes the memories on its own | partialgenerates 1 file | partialgenerates documentation | yes8 traceable phases |
Your source code stays on your computer. Your account's server holds conversations, decisions and audit. Never your code.
The agent edits the project where it already is, and the tools run there. Your code isn't copied anywhere.
The index that makes search by meaning possible is built and kept on your machine. It is born there and it stays there.
Every AI call goes through your account's server, which injects the credential. The desktop never receives the key.
Folders, tools and a brake on destructive actions. A subagent never gets more permission than its caller.
It isn't the agent behaving well: the key simply isn't there.
Learn moreWho builds it, who ships it and who takes it to market.
Founder / AI Systems Architect
25+ years of engineering. Wrote Kodzonia with Kodzonia itself and runs production systems built with it.
LinkedInCo-founder / Platform Engineer
Platform engineering and delivery: front end, back end and the infrastructure that puts the product in users' hands.
LinkedInCo-founder / Product Engineer
Commercial operations, relationships and go-to-market. Structures the business to grow on solid ground.
LinkedInCRO / Business Director
20+ years of experience in business expansion, strategic partnerships and revenue acceleration in the technology market.
LinkedInYou talk directly to the people building it.
Learn moreAn AI team that works inside your project — reads the code, edits, runs commands, tests, queries the database and drives the browser — under your company’s control: scope declared by you, permission by impact level, and every call audited with model, cost and duration.
Yes. Four production systems were built with Kodzonia for third parties: a payments platform and three systems inside an enterprise ecosystem with decades of code. The fifth is the product itself.
For whoever builds software — from scratch or on top of what already exists. The independent dev opening a clean project today who wants to deliver tomorrow; the software house minding code for several clients; the product team with legacy few people understand; the company with hundreds of developers that wants AI with governance — including decided by someone who does not write code: scope, permission and cost are declared and audited, not trusted. Born with Kodzonia or bringing thirty years of code, the AI team is the same — and it grows with yours, not against it.
Yes — and that is what makes the rest possible. You sign in with a Zonialabs account and the project becomes a resource of it: conversations, memories, decisions and audit are available to whoever you authorize, on any machine. Without an account, each person would be an island with an API key in their pocket. Your source code still stays only on your machine.
Two roles. Whoever governs decides the providers, which models are available to the team, at what capability tier each one runs and which ones automatic routing may pick from, the permissions and the limits — tracks per-person cost on the panel, invites by email and revokes access on the spot. A member opens the project and works, with the same history and memories the team built. Governance here is not bureaucracy: it is the power to decide, see and cut — with everything on record.
Whoever manages the team, in one place. The credential lives on your account's server and is injected into the call by the server — the desktop never receives it. Rotating is a single act that holds for everyone; removing someone from the team removes access at the same instant. Nobody needs to paste a key into a config file to get to work.
Yes. Every call becomes a line with model, tokens, cost and duration, attributed to the project and to whoever triggered it. Spend aggregates per member, per day and per project. Team cost stops being an estimated split.
Yes. You connect the provider account your company already uses and consumption is billed there, by the provider. The difference is where the key lives: in your Zonialabs account’s vault, used by the server on every call and never handed to the desktop. Work with another provider? The answer fits in one conversation.
Today: 18 models from Anthropic, OpenAI and Kimi, side by side in the same catalog, each with a verified fact sheet — limits, formats, capabilities; what isn't known stays blank instead of becoming a guess. Switching models rewrites nothing: the tools, the memory, the specialists and the audit belong to Kodzonia, not to the model. And the provider policy is yours: the project only uses the providers you authorize — no others. The catalog is growing: support for DeepSeek, Muse Spark 1.3 (Max) and GLM is on the way, to the same standard. Use another provider? The answer fits in one conversation.
You swap the engine and the project continues exactly where it was. Memory, specialists, workflows and audit belong to Kodzonia, not to the model — a provider outage or a policy change does not stop your team.
Yes, by construction. Conversations, memories, decisions and audit belong to your project. Your code was never anywhere but where you work.
Every model call becomes an audit line with model, tokens (cache included), duration and error, plus the tree of which agent called which. The panel aggregates by day, model and tool, and exports to CSV.
It opens the real project and works in it: reads the code, edits, runs the test suite, reads the error, fixes it and runs again. Before it reaches you, another specialist reviews what was done — code review is a role on the agent team, not a favour someone does at the end of the day. You get the work already reviewed, diff in hand: approve it, ask for changes, or review it yourself whenever that makes sense. And what was learned along the way can become project memory: the rule explained once never needs explaining again, not to it and not to whoever joins later.
macOS today. It is a native desktop app — you install it, open it and sign in with your Zonialabs account; the project shows up with the team’s history. The Windows version is in development: join the list telling us which system you use, and we will let you know when it opens.
It depends on the model and the size of the tasks — which is why the product measures instead of estimating. The panel shows consumption per call, per day and per project from week one, so you find your number with your code, not someone else's average. And FMR — our model-routing technology — uses a light model for what is simple, saving the expensive one for when the task is about to change things.
That is exactly what the beta is. You get in, use it on real code and decide from your own experience. Whoever joins now also talks straight to the people building it and shapes what comes first.
By email, at contato@zonialabs.com, and on the other end is whoever wrote the code — no support tier in between. We answer within one business day.
What belongs to the project — conversations, memories, decisions, audit — lives in your Zonialabs account, under your own access control, and the source code never leaves your machine. If you want to leave, we hand over the project's data. If your legal team wants that in writing, it goes into the contract.
We do. Bring your legal team’s template or use ours — we settle it in conversation, before any access.
The product is used daily on real code, including to build itself, but it is not in open production yet. Whoever joins now follows it closely and shapes the priorities.
Question not here? We answer directly, no funnel.
Learn moreA name and an email are enough. The rest is optional.
We email you when your spot opens. Beta start: November 5, 2026.
You create your account, pick a plan and install the app on your Mac.
Pricing: 30-day plans from R$ 55 to R$ 669, plus on-demand packs.
Leave your name and email and we will tell you when your spot opens. Prefer to talk first? We show it on your kind of code.