Your own AI development assistant, on your own servers.
An assistant that knows your documents, your code and your way of working: it answers questions, onboards developers, turns tickets into plans and prepares pull requests for a person to approve. Built on your infrastructure for a fixed fee, with a working pilot in three months.
Hosted coding assistants are quick to start and good at writing code. What they cannot know is your company: the documents nobody reads twice, the reasons behind an old design, the way your team names things. This assistant is built around that knowledge. It runs on servers you control, on open-source models, and its cost does not grow with every developer who joins.
Who it's for.
- Software agencies and product companies with several teams and a growing codebase
- Engineering leaders who want AI in the delivery process without sending code and documents to a third party
- Teams that onboard developers often, or lose days whenever someone has to understand an old system
- Companies where the bill for hosted assistants grows with every seat
What you get.
Not a chatbot: a system that works inside your repositories, your documents and your task flow, and leaves a person in charge of every decision that matters.
A knowledge base from your documents
Specifications, wikis, meeting notes and contracts turned into structured, searchable knowledge, with the source and the date behind every answer, and refreshed as the documents change.
Developer onboarding
An onboarding path for each role: project overview, setup guide, architecture summary and first tasks, generated from the real codebase and kept current.
Code understanding
Search, inspect and explain code across all your repositories, so an unfamiliar or legacy system can be understood without days of reading.
Tickets into plans
Requirements, tickets and client requests turned into a structured plan: the modules affected, acceptance criteria and a test plan, ready for a developer or for the agent.
A coding agent that prepares pull requests
Given a task, it reads the repository, proposes a plan, applies the changes, runs the tests and linters, fixes what fails and opens a pull request. A person approves the plan and the result.
Private and safe by design
Open-source models on your infrastructure, an isolated workspace for the agent, no access to secrets or production, no destructive commands, and a log of everything it did.
Workflows it comes with.
Each one starts from something your team already produces and ends with something a developer can act on.
- New feature: from a client request to a technical summary, acceptance criteria and a test plan
- Bug fix: from a report to the suspected cause, the related files, a fix plan and a regression test
- Onboarding: from a new hire to a productive developer, with a plan for the first days, the documents to read and the first tasks
- Pull request review: a change summary, risk areas, missing tests, security concerns and the documentation to update
- Project documentation: an architecture summary, setup and deployment guides and a developer FAQ, written from the repository itself
- Coding agent: from a task to a pull request, with the plan, the patch, the tests and the final diff shown before anyone approves
How the agent works.
Give it a task. Everything happens in a controlled workspace, and nothing reaches your main branch without a person's approval.
Reads
Opens a temporary branch and reads the project memory: the documents, the conventions and earlier decisions.
Plans
Inspects the repository, finds the relevant code and proposes a plan, and waits for your approval before it changes anything.
Builds
Applies the changes, runs the tests and the linters, and fixes what fails.
Hands over
Shows the final diff and prepares the commit or the pull request once you have approved it.
What it is made of.
A web app or a command-line tool for the developers. Behind it, an orchestrator that looks at each task and routes it to the most suitable model: a small, fast one for a lookup, a larger one for reasoning about code or architecture. That routing is what keeps the cost of running it low without lowering the quality of the answers.
Under those sit four layers. The knowledge layer processes the documents and builds the project know-how. The task-flow engine turns requirements and tickets into development work. A sandbox gives the agent an isolated workspace, with no access to secrets and a full audit log. And a pool of open-source models runs on your own hardware or private cloud, so nothing depends on a single vendor.
Why build your own.
Hosted assistants and a private one solve different problems, and many teams end up with both. This is what the private one adds.
A hosted coding assistant
- Quick to set up, strong models and a polished developer experience
- Understands the repository in front of it
- A usage bill that grows with the team
- Little control over models, workflows and coding standards
- Your private knowledge stays outside it, and your code goes outside the company
Your own assistant
- Runs on your infrastructure, with your data under your control
- Connected to your documents, tickets, repositories and onboarding
- Routes each task to the right model, so the cost stays predictable as the team grows
- Follows your own workflows and coding standards
- Handed over with its documentation: the system is yours
Three months to a working pilot.
Three stages with something to use at the end of each, for a fee agreed before the first one starts.
Foundation
Architecture and model selection, the model runtime on your hardware, a first benchmark, the document pipeline, the first knowledge base and the security rules.
Workflows and agent
The project know-how builder, onboarding flows, task breakdown, repository search and code reading, planning mode, the safe workspace and the first generated patches.
Coding pilot and handover
File editing, test runs, linters, the fix loop and pull request preparation, then a model comparison report, a cost recommendation, a developer guide and the handover.
What the fixed fee covers.
The fee is agreed up front and does not move. The infrastructure the system runs on is the one cost that stays with you, because its size depends on your team.
Included
- Architecture and model selection, with open-source models benchmarked on your own tasks
- The model runtime set up on your servers or private cloud
- The document pipeline and the knowledge base
- Onboarding flows and the project know-how
- Task breakdown, bug-fix and pull request review workflows
- Repository search and code understanding
- The coding agent, with its sandbox rules and command restrictions
- An infrastructure recommendation, a developer guide and the handover
Not included
- GPU or cloud capacity, rented by you directly from the provider at the size that fits your team
- Running a large production cluster
- Training or fine-tuning models from scratch
- Enterprise single sign-on
- Migrating every document and repository
- Rolling the system out to the whole company; the pilot ends with a roadmap for that
- A guarantee that it replaces the hosted assistants your developers use today
- Unlimited support after delivery; a retainer covers that if you want it
Common questions.
Something else on your mind? Email us.
Which models does it use?
Open-source models served on your own hardware or private cloud, chosen and benchmarked on your tasks during the first month. Where your data allows it, an API model can be added for the hardest reasoning tasks, and the router decides per task.
What do we need to provide?
Access to your documents, repositories and ticket system, a server or cloud account with a GPU, and a few hours of your senior developers' time each week for feedback and approvals.
How is our code kept safe?
The agent works in an isolated workspace on a temporary branch. It has no access to secrets or production systems, cannot run destructive commands, and asks for approval before any commit or pull request. Everything it does is logged.
Does it replace the hosted assistants we already pay for?
Not necessarily, and we do not promise that it will. It does the work they cannot: answering from your own knowledge, onboarding people and running your workflows on your infrastructure. Many teams keep both and move work across as the private one proves itself.
What happens after the three months?
You have a working pilot, a report comparing the models on your tasks, a cost recommendation and a roadmap to production. From there we can run and extend it with you, or your team takes it over with the documentation.
Why a fixed fee?
Because the scope is known. The system, the stages and the deliverables are the same for every client, so the price can be agreed before we start. The only cost that varies is the infrastructure you rent.
Other ways we can help.
AI automation & agents
Agents that take repetitive work off your team, and in time entire functions. In operations: documents, records, bookings and reports. In engineering: tests, tickets, code review and releases. Built, tested and monitored by engineers.
AI products & systems
Web, mobile and API products and internal platforms designed around AI from the first version, grown into the complete system, and run in production.
Mobile app development
iOS and Android apps from one codebase, designed and built the way large consumer products are, with AI inside where it makes the app better: from the first release through the app stores to the updates after launch.
Data & decision intelligence
Large volumes of operational and financial data turned into dashboards, analysis and forecasts, with AI writing the read-out, so decisions get made on evidence, in minutes rather than weeks.
Executive & board advisory
An independent sounding board for C-level leaders and board members, and a mentor for the teams below them: AI strategy, pricing and growth, product and mobile UX, data, and organization and change across regions.
Tell us what you're working on.
A 30-minute conversation about your business, and a clear view of what we would do first. No obligation.