An AI coding assistant for regulated, air-gapped organisations

iChat is IOTA’s AI coding assistant for organisations where source code is itself a regulated asset and cloud assistants are therefore not permitted. It runs in VS Code, in JetBrains IDEs and in the terminal, against models you host yourself. Nothing leaves your network.

How it is built

iChat brings clients for VS Code, JetBrains IDEs and the terminal. They talk to one iChat service inside your network. The iHarness engine at its core shapes every request, runs the agent and its tools, checks every tool call and records everything. Behind it sit your own models and your existing enterprise systems.

• Clients — the VS Code extension and the JetBrains plugin show a chat panel and proposed changes in the IDE’s own diff view; the terminal client offers interactive chat, scripting, code review in CI and loops. All three share client-side masking, project memory, file references, plan mode and rewind.

• Access — sign-in with your identity provider, roles and model access, offline licensing and seats, rate limits and token budgets.

• Engine — iHarness, the same core that is sold on its own: it shapes, runs, checks, loops and records every request.

• Knowledge — offline answers grounded in your internal documents, and meaning-based code search across your repositories, with citations.

• Guardrails everywhere — secrets and personal data masked on client and server, approved-package checks, security scans of generated code, safety modes, encrypted chat history, and every request and tool call audited.

• Your models and systems — a bundled model server and coding model, or your own model servers or private cloud through a standard interface; your identity provider, security and monitoring platforms, policy engine, code hosting, metrics and logs, plugins and repositories.

One codebase, two editions: iChat, with single sign-on and IDE clients, and iHarness, with access keys, for the tools you already use. Both are deployed as one package inside your network, and the licence is checked offline. The architecture diagram is in the product deck, available on request below.

A full coding assistant inside your IDE

• Edits you review — proposed changes appear in the IDE’s own side-by-side view, with apply and undo for every change.

• Plan mode — the assistant writes a step-by-step plan and changes nothing until you approve it.

• Project memory — a simple project file tells the assistant how your project works, and the assistant can draft it for you.

• File references and rewind — point the assistant at specific files, and step back to any earlier point in a conversation.

• Skills and skill packs — a built-in library of workflows for review, QA, planning and security. Users switch on packs for their stack, from front end to back end and integration platforms.

• Guardrails — sensitive data is masked on both the client and the server. Safety modes limit what may change, protected files are enforced, and chat history is encrypted.

• Automated code review — AI review in your build pipeline or before each commit, with results shown in your code-scanning dashboards.

• Knowledge and code search — answers can be grounded in your internal documents and in meaning-based search across your repositories, all offline.

• Terminal client — set up and check the model connection in seconds.

Agents that check their own work

Most AI assistants answer once and stop. iChat can now run loops: agent runs that start without anyone prompting them and keep working until the result passes your checks.

• Start on their own — loops start on a schedule (nightly, hourly, weekdays at nine) or when something happens in your code repositories, such as a push or a new change request. Every trigger is verified before a loop runs.

• Stop only when the work is right — a loop finishes when your own lint and test checks pass, when its answer matches what you expect, or when a separate reviewer agent checks the work and approves it.

• Learn between attempts — each new attempt is told exactly which check failed and why.

• Stay within budget — each loop has a limit on tokens, time and attempts. When it cannot finish within them, it hands over to a person in your team chat or ticketing tools. That person can add guidance and resume it in one step.

• Leave a record — every run keeps a readable progress and decision log, and every step is in the audit trail.

• Same guardrails as people — loops act under a named identity with its own roles. They get the same masking of sensitive data, tool-call checks, policy decisions and audit as any user.

Loops fix things rather than report them. A loop can work on a private copy of your repository, with your application running from it, and check the application the way a person would.

• Using the application — it sends real requests to the running application.

• Reading its logs — it reads the application’s own log output.

• Opening it in a browser — it loads pages the way a user would and sees errors, crashes and failed requests. Nothing extra needs to be installed, so this works air-gapped.

• Watching production — it checks your existing monitoring for error rates and latency.

When every check passes, the changes are packaged for review. They are proposed back to your repository only after your policy rules or a named person approve. The original code is never touched before that.

What a loop is worth is measured per loop: success rate, attempts per success, tokens per success, median run time and changes delivered. The figures are available in the terminal, through the API and on your existing dashboards. Any access key can also carry a daily or monthly token budget, so an IDE’s agent mode or an automated pipeline cannot run away with your GPU time.

Think-first answers from the model you already run

The best coding assistants do not jump straight to code. They work out what is being asked, look at what the change touches, plan, and check the plan before they write a line. iChat brings that discipline to the models you host yourself, with no retraining and no new hardware.

• Understands before it answers — every request starts with the assistant restating the task and naming any assumption it has to make.

• Plans the change — it maps the files and functions involved and sets out the steps. For a bug, it lists the likely causes and how to tell them apart.

• Thinks about what could break — edge cases, error handling, security and the effect on existing callers and tests are part of the plan.

• Checks its own plan against the request before it answers.

• Clean, consistent answers — the result comes first, code is clearly marked, and every answer ends with how to verify the change. The working-out stays out of the answer, the saved history and your automated checks.

• Reasoning on request — tools that can show the reasoning get it separately. Tools that cannot simply get the clean answer.

• You decide where it applies — switch it on for the whole organisation or only for chosen models. Strict machine-readable answers are left untouched.

• Fully accounted for — reasoning stays inside your network, counts against token budgets and is recorded in the audit trail.

The improvement comes from how the iHarness engine guides the model, not from training on another vendor’s output, so there are no new provenance or licensing questions for your compliance teams.

Licensed for the real world

Licences are signed files verified locally. Evaluation licences renew monthly, production licences renew yearly, and a grace period means an expiry never strands engineers mid-sprint. Seats, features and tenants are all in the signed payload; renewal is dropping in a new file. There are no calls home.

Built for regulated environments

Everything runs inside your network. There are no calls home, licences are checked offline, and every request, tool call and loop run is audited. iChat follows current industry and research best practice for building safe, reliable AI agents.

Status

iChat is available today. Request access: tell us about your environment through the form on our home page and our team will connect with you. The product deck, with the full architecture, is available on request below.