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.
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.
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.
What goes in and what comes out for each role?
| Who | Goes in | Comes out |
|---|---|---|
| Development | The codebase and its documentation | Code written with agents, tests and refactors to review |
| Operations and support | The codebase and its documentation | Automated support and repetitive tasks |
| Engineering and technical office | Technical documentation, standards and your own projects | Tender documents, technical reports and bids |
| The whole team | Questions about the technical documentation | Answers drawn from that documentation |
| Project meetings | The audio of the meeting | Transcript and minutes with a summary |
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.
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.
| Task | What the assistant does | What the person checks |
|---|---|---|
| Completing as you type | Suggests 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 code | Explains what a selected function, module or file does | That the explanation matches what the code really does, edge cases above all |
| Refactoring | Proposes the change as a diff on the selection | The whole diff before accepting it, and the tests afterwards |
| Writing tests | Generates tests next to the original file | That they test the behaviour that matters, not only what already passes |
| Fixing errors | Proposes a fix for the errors in the file | The cause: that the fix does not merely hide the symptom |
| Longer jobs for an agent | An agent works on the task in an isolated branch and leaves the result for review | The usual code review, before merging |
| Technical documentation | Drafts it from the code or from existing documentation | That it does not describe functions that do not exist |
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.
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.
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.
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.
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.
| Question | Why it matters | With MagnolIA |
|---|---|---|
| Where does the model run? | That is where every fragment of code you send is processed | On 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 not | Monitoring 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 outside | No: it does not leave the machine in your network |
| Does it work with the tools we already use? | Changing editor or agent has a cost | An 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 server | Stored 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 reconstructed | Per-user usage log and a chained, verifiable audit trail |
| Who chooses and updates the models? | Coding models change quickly | MagnolIA selects, tests and updates them |
For the wider conversation with an AI provider, beyond code, see the eight questions for a private AI provider.
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.
How do you start a pilot with the development team?
Pick one team and one repository
A real one, with its history and its quirks. A demo project says nothing about yours.
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.
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.
Set the rules before you start
Who reviews, what is never merged without review and which actions need approval.
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.
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.
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.
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.
Installation
MagnolIA installs the machine in your office. You do not buy it: it is included in the fee.
Tuning and integration
The models are loaded and tuned, and the integrations with your systems are set up.
Pilot
A group of 10 to 20 people works with it on their own documents.
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.
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.
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
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


