Skip to content
Industries · Software and engineering

On-premise coding assistant: your code never leaves the company

Updated
By
The MagnolIA team
On this page
14 min read

Short answer

A development team or an engineering firm can use coding agents and an in-editor assistant without its code leaving the company. MagnolIA installs the model server in its network, with an API compatible with OpenAI's and Anthropic's: Claude Code, Cursor or Cline work by changing only the server address and the key.

Back to contents

Why shouldn't code leave the company?

Because the code and the technical documentation are the product. A cloud coding assistant receives fragments of the repository with every request, and an agent walks the whole project: files, configuration and, sometimes, client data that lives in it. All of that is processed on another company's servers.

There is a legal reason too. Spain's Law 1/2019 on Trade Secrets, which implements the EU Trade Secrets Directive, protects information that is secret and valuable because it is secret, and adds a third condition in article 1: the holder must have taken reasonable steps to keep it secret. Where the code is processed can be one of those steps.

With the model inside the network, code goes from the editor to the company's server and back. In the reference deployment for a software company, that is exactly the reason for keeping it inside: code does not leave. For an engineering firm, it is that intellectual property and R&D stay within the company.

Back to contents

What does a development team get?

Compatible API
MagnolIA Server exposes endpoints compatible with the OpenAI API and the Anthropic API. The tools the team already uses, such as Claude Code, Cursor, Cline or your own integrations, work by changing only the server address and the key.
Claude Code against your server
Claude Code terminals already configured against the models on your server, organised by project. Every session is recorded and can be resumed or forked.
VS Code extension
MagnolIA for VS Code brings a chat about your code into the editor: ask about the selection, explain, refactor with a diff, write tests and fix the errors in the file, with optional inline completion. It runs on VS Code 1.96 or later, Cursor and VSCodium, on macOS, Windows and Linux.
Agents that work as a team
In MagnolIA Nexus, the agents on a project share a board and a memory, reserve the files they touch and notify each other of changes. On the kanban board, each card can be assigned to an agent that works on an isolated branch; the result is reviewed before it is merged.
Models per task
Open-weight models selected, tested and updated by MagnolIA, with profiles per task: fast answers, code, writing or in-depth analysis.
Scoped keys
API keys are stored only as hashes, scoped by model and machine, with configurable expiry and instant revocation. There are per-user quotas and a usage log.
Back to contents

What goes in and what comes out for each role?

Uses of on-premise AI in software and engineering: what goes in and what comes out
WhoGoes inComes out
DevelopmentThe codebase and its documentationCode written with agents, tests and refactors to review
Operations and supportThe codebase and its documentationAutomated support and repetitive tasks
Engineering and technical officeTechnical documentation, standards and your own projectsTender documents, technical reports and bids
The whole teamQuestions about the technical documentationAnswers drawn from that documentation
Project meetingsThe audio of the meetingTranscript and minutes with a summary
Code and documents go from each person's desk to the company's server and back. Only the monitoring of the machine's status travels outside.
Back to contents

And in an engineering firm? Tenders, reports and technical documentation

In an engineering or industrial company the sensitive material is not only code: it is your own projects, technical documentation and standards. The reference deployment, described in the on-premise AI use cases, is used by engineering, the technical office and the business side to prepare tender documents, technical reports and bids, and to ask questions of the technical documentation.

The server generates embeddings for semantic search and RAG over your documentation, and the models create and read Excel files with formulas and charts, Word, PowerPoint and PDF. If a document has to leave, the Nexus anonymiser first replaces the personal data and keeps the key to revert it.

Back to contents

What is a coding assistant used for day to day?

For the work around writing code as much as for writing it. Every task has a part the assistant does and a part that stays with the person: the second column is no use without the third.

Common tasks with an on-premise coding assistant: what the assistant does and what the person checks
TaskWhat the assistant doesWhat the person checks
Completing as you typeSuggests the rest of the line or block. In the MagnolIA extension, inline completion is optional and uses the server's fast model.That the suggestion is what was intended, not just something that compiles
Understanding legacy codeExplains what a selected function, module or file doesThat the explanation matches what the code really does, edge cases above all
RefactoringProposes the change as a diff on the selectionThe whole diff before accepting it, and the tests afterwards
Writing testsGenerates tests next to the original fileThat they test the behaviour that matters, not only what already passes
Fixing errorsProposes a fix for the errors in the fileThe cause: that the fix does not merely hide the symptom
Longer jobs for an agentAn agent works on the task in an isolated branch and leaves the result for reviewThe usual code review, before merging
Technical documentationDrafts it from the code or from existing documentationThat it does not describe functions that do not exist
The editor features are those of the VS Code extension running on your own AI server. Engineering and technical-office tasks are covered in the previous section.
Back to contents

Is an on-premise coding assistant as good as a cloud one?

It cannot be taken for granted, and it is worth being wary of anyone who does. An on-premise assistant runs on open-weight models; the big providers' proprietary models cannot be installed on your own hardware. How much the difference shows depends on the model, the language, the size of the repository and the kind of job, and it shifts with every generation of models.

That is why this page gives no percentages or league tables: no test built on generic exercises tells you how an assistant behaves on your code. The honest way to find out is the pilot: the same real tasks, on your repository, with the team deciding whether the result is good enough.

What you gain
The code does not leave the company, the cost does not depend on how many requests each person or agent makes, and the work does not depend on an outside provider's availability or changes of terms.
What you may lose
The latest proprietary model of the moment. If the organisation so decides, the terminals can also use an Anthropic account for work that is not confidential; whatever is sent that way leaves the network.
What does not change
Generated code has to be reviewed all the same, whichever model wrote it.
Back to contents

What if the assistant suggests insecure code or invents a dependency?

It can happen with any assistant, wherever the model runs. The 2025 edition of the OWASP Top 10 for LLM Applications lists it under risk LLM09 (Misinformation) as unsafe code generation: "The model suggests insecure or non-existent code libraries". It also describes a specific attack: someone works out which package names coding assistants commonly make up and publishes malicious packages under those names.

Agents add another risk from the same list, LLM06 (Excessive Agency): the system can carry out damaging actions because it has more functionality, more permissions or more autonomy than it needs. The measures OWASP proposes are the familiar ones, applied to AI: minimum permissions and human approval for high-impact actions.

  • Human review of everything that is merged. The assistant proposes; someone on the team answers for the change.
  • The same controls as for hand-written code: tests, static analysis and dependency checks in continuous integration.
  • Check that every new dependency exists, is the one you think it is and is maintained, before installing it.
  • Minimum permissions for agents. In MagnolIA, the agent works in an isolated branch and its result is reviewed before it is merged; in the terminals you can require every action to be approved.
Back to contents

Who owns generated code, and what about licences?

That is a legal question this page does not settle: it is for your legal adviser, with your contracts on the table. What you can do is bring them well-framed questions.

  • The model's licence. Every open-weight model has its own, and they do not all allow the same things. It is worth knowing which models you work with and on what terms.
  • Resemblance to other people's code. A model can suggest fragments that resemble code published under a licence. The risk is assessed and managed with review and with whatever licence-scanning tools the team already uses.
  • What you have agreed with your clients. If the contract says anything about authorship of the code, about the use of AI or about where the client's code may be held, that governs.
Back to contents

What should you not leave to a coding assistant?

  • Merging changes without review. Neither into the main branch nor into production.
  • Handling secrets. Passwords, keys and production credentials should not be in the repository or in anything the agent can read.
  • Running actions that cannot be undone (deleting data, deploying, migrating a database) without a person approving them.
  • Installing dependencies nobody has checked.
  • Deciding the architecture or the requirements. It can propose alternatives; the decision and its consequences belong to the team.
  • Signing for an engineer. In an engineering firm, a generated calculation, report or tender document is a draft: responsibility stays with whoever signs it.
Back to contents

What should you ask any coding-assistant provider?

"Self-hosted" and "on-premise" are used for different things: sometimes the editor is inside while the model, or the agent that decides the steps, is outside. These questions work for any provider; the third column gives MagnolIA's answer.

Seven questions for a coding-assistant provider, and MagnolIA's answer
QuestionWhy it mattersWith MagnolIA
Where does the model run?That is where every fragment of code you send is processedOn the server installed in your network
What leaves the network, besides the requests?Telemetry, web searches or connectors can carry out what the model does notMonitoring of the machine's status. Web search and connectors to outside services, only if you use them
Is our code used to train models?It is one of the ways code can end up outsideNo: it does not leave the machine in your network
Does it work with the tools we already use?Changing editor or agent has a costAn API compatible with OpenAI's and Anthropic's: you change the address and the key
How are keys managed?A leaked key gives access to the serverStored only as a hash, scoped by model and machine, with expiry and immediate revocation
Is there a record of who used what?Without one, an incident cannot be reconstructedPer-user usage log and a chained, verifiable audit trail
Who chooses and updates the models?Coding models change quicklyMagnolIA selects, tests and updates them

For the wider conversation with an AI provider, beyond code, see the eight questions for a private AI provider.

Back to contents

Is it proven? A pilot at a software company

An on-premise AI pilot is under way at a software company. It validates the agentic coding case for the development team, with the code always inside the company.

Back to contents

How do you start a pilot with the development team?

  1. Pick one team and one repository

    A real one, with its history and its quirks. A demo project says nothing about yours.

  2. Clean up what the agent will be able to read

    Secrets, credentials and client data that have ended up in the repository. It is a good moment to get them out.

  3. Choose five or six real tasks

    An open bug, a module with no tests, a legacy function nobody understands, an overdue refactor. The same ones throughout the pilot.

  4. Set the rules before you start

    Who reviews, what is never merged without review and which actions need approval.

  5. Note what is accepted and what is thrown away

    By task and by person. That is the measure that counts: the team's opinion of its own code, not a third party's figure.

  6. Decide on that basis

    Which tasks to keep it for, under what rules and for how many people. That also sets the capacity you need.

What should you check before giving the repository to a coding assistant?

  • We know where the model runs and what leaves the network.
  • The repository contains no secrets and no real client data.
  • Our client contracts allow AI to be used on their code, or we have asked.
  • Each person signs in with their own user and password; there are no shared keys.
  • Agents work in isolated branches with only the permissions they need.
  • Nothing is merged without human review and passing tests.
  • New dependencies are checked before they are installed.
  • One person owns the rules and reviews them after the pilot.

The rules for the rest of the staff, beyond the technical team, are in the house rules for AI at work.

Back to contents

How is it installed, and what stays inside the network?

MagnolIA delivers it installed and keeps it running: your team writes software, it does not operate model servers (the alternative is compared in self-hosted or managed AI server). The reference deployments for software and for engineering start on Núcleo M, and capacity is added without downtime.

  1. Assessment

    We look at how many people will use the AI, what for, and which systems it needs to talk to. That sets the capacity.

  2. Installation

    MagnolIA installs the machine in your office. You do not buy it: it is included in the fee.

  3. Tuning and integration

    The models are loaded and tuned, and the integrations with your systems are set up.

  4. Pilot

    A group of 10 to 20 people works with it on their own documents.

  5. Production

    The whole staff, with corporate sign-in, monitoring and backups.

Stays inside
Prompts, documents and answers. They are processed on the machine installed in your network and stay there.
Also inside
The per-user usage log and a chained, verifiable audit trail, kept for two years.
Leaves
Only the monitoring of the machine's status: load, health and security. MagnolIA does not see the content.
Access
Each person signs in with their own user and password through a single entry point encrypted with TLS. Remote access is optional and runs through an authenticated outbound tunnel.

The extension keeps the key in the system's secure store, never in settings, and does not touch .mcp.json or CLAUDE.md. The server's measures are in on-premise AI security, the payment model in what on-premise AI costs and the basic definition in what on-premise AI is.

Back to contents

Frequently asked questions from software and engineering teams

Is it compatible with the tools my team already uses?

Yes. MagnolIA Server exposes endpoints compatible with the OpenAI API and the Anthropic API. The tools your team already uses, such as Claude Code, Cursor, Cline or your own integrations, work by changing only the server address and the key.

Is an on-premise coding assistant as good as a cloud one?

An on-premise coding assistant runs on open-weight models, because the big providers' proprietary models cannot be installed on your own hardware. Whether it performs as well depends on the model, the programming language and the kind of job. The reliable way to find out is a pilot with real tasks on the company's own repository.

What are the risks of AI-generated code?

AI-generated code can be insecure or rely on libraries that do not exist, a risk listed in the 2025 OWASP Top 10 for LLM Applications. Keeping the model inside the network does not prevent it. It is reduced with human review, tests, dependency checks, and agents that have minimum permissions and need approval for sensitive actions.

What does the MagnolIA extension for VS Code do?

The MagnolIA extension for VS Code brings your MagnolIA Server's models into the editor: a chat about your code, Claude Code terminals preconfigured for your server, skills and MCP connectors, the machine panel and the Nexus board and memory for the open project. Requests go to your server with your key, stored in the system's secure storage.

Does the extension write to my repository?

Very little. The MagnolIA extension for VS Code only adds a line to the project board if you post something from the World view, and it writes what you ask for: a file from the chat, some tests or whatever Claude Code produces as part of its work. It does not touch .mcp.json or CLAUDE.md and leaves no temporary files.

Can third-party models such as Claude be used as well?

Third-party models are used only if your organisation decides to use them: MagnolIA does not connect them on its own initiative. If enabled, Nexus can work with Anthropic accounts alongside your server's models, and the anonymiser lets that external model receive only the copy with personal data removed.

Sources

External figures on this page link to their original source.

  1. BOE (Spain's Official State Gazette). Law 1/2019 on Trade Secrets, article 1 (in Spanish). www.boe.es/buscar/act.php?id=BOE-A-2019-2364

  2. OWASP Gen AI Security Project. OWASP Top 10 for LLM Applications 2025: LLM06 Excessive Agency and LLM09 Misinformation. 2025 edition. genai.owasp.org/llm-top-10/

Shall we try it on your repository?

Tell us how many people write code, with which tools, and what cannot leave. The pilot runs with a group of 10 to 20 people.

Request a pilot