Development platform

kForge

Git repositories, continuous integration, code analysis and deployment metrics — brought together in a single multi-tenant application, on your own servers. Twelve isolated clients, one installation, one upgrade. And the bill does not depend on how many developers you have.

Natively multi-tenantSelf-hostedDrivable by AI agents, with no shellNo per-user billing

kForge dashboard: tracked projects, repositories aggregated from several forges, recent git activity and ingested issues

Your development tools cannot count to two clients

GitHub Enterprise, GitLab Self-Managed, Jenkins, CircleCI: all excellent, all built for ONE organisation. The day you serve several — because you are a service company, because you have subsidiaries, because each entity must be isolated — you do not configure one more client. You install one more platform.

Twelve clients means twelve subscriptions, twelve admin consoles, twelve upgrades to schedule, and the same question asked twelve times by your operations team.
Next to the forge there is almost always a CI engine billed by the minute or by the seat, and a code-analysis tool with its own licence and its own notion of a user.
Then a spreadsheet, or one more subscription, to produce the deployment metrics you present to the board.
And an issue tracker that ignores commits, with commits that ignore issues.
Four products, four notions of a user, four audit trails — and nobody able to answer plainly: “what exactly did this release ship?”

What kForge brings

The four products in a single application, with one client model and one installation. Your repositories stay where they are: kForge aggregates them, runs your pipelines, analyses your code, and computes your metrics on what it actually deployed.

Your repositories, whatever the forge

A project aggregates GitHub, GitLab and local repositories — including bare repositories on your own servers, which most tools simply ignore. History, branches, tags, diffs, blame, full-text commit search, and reference comparison across several repositories of the same project. Pull requests and forge issues are mirrored and readable without switching tabs.

Real-time change tracking, by polling and by signed webhooks (GitHub, GitLab).
A forge issue becomes a kForge issue, with its labels and its history.
A commit links to an issue, and the issue shows the commits that resolved it.

kForge project list: each project aggregates several repositories, with its status and its activity — One project, several repositories — whatever forge they come from

Tracked repositories, with their provider (GitHub, GitLab, local), default branch and last synchronisation — Aggregated repositories, GitHub and GitLab side by side

Issues mirrored from the forges: title, state, labels and author, readable without switching tabs — Forge issues, on the same screen as the code

Continuous integration that invents nothing

Stages, jobs in a dependency graph, matrices, execution in a shell, a container, Kubernetes or over SSH. Nine trigger types, two of which no competitor offers: periodic execution of a sandboxed script, and URL polling with a no-loss guarantee, including across a restart.

Twelve quality gates block a release on test coverage, measured latency, security findings or a regression against a baseline.
Your pipelines import and export as YAML — and also export to GitHub Actions format. We ship the button that lets you leave.
kForge has no scheduler of its own, no runner of its own, no artefact store of its own: it compiles your pipelines down to the Kore platform, which executes them.

CI/CD dashboard: pipeline health, recent runs, DORA metrics and analysis findings on one screen — Pipelines, their runs, and the metrics that follow from them

Code analysis, with a life cycle

Twenty-eight built-in analysers, plus your own, grouped into profiles. A finding is not a log line: it has a fingerprint, it is muted or suppressed durably — the exclusion survives later runs — and its fix is proven from one run to the next. A finding becomes an issue or a risk in one gesture, without duplicates.

A triage tool, not a counter: the sorting is where the value is, and that is where the work went.
We do not sell static analysis as a vulnerability detector. A static finding is a hypothesis — the engine sees the sink, never the guard sitting just above it. That is why the product tools verification rather than volume.

Code analysis screen: analysed repositories, findings by severity, the trend across runs, and the analysers behind each result — Findings, their severity, and how they move from one run to the next

The metrics you present to the board

Deployment frequency, lead time for changes, time to restore service, change failure rate — computed on your real runs, with automatic performance-level ranking.

And counted on both paths: deployments launched by a pipeline AND those launched from the command line.
A metric that saw only half of reality would be worse than no metric — because it would look credible.

The four DORA metrics computed on real deployments: deployment frequency, lead time for changes, time to restore service and change failure rate, each with its performance level — The four metrics, each with its performance level

An AI that works on your code without being given a machine

Most development assistants assume two things: command-line access, and a machine to work on. For many organisations that is precisely what makes AI unacceptable — and the conversation ends there. kForge takes the other path: the application exposes 63 tools to an agent, grouped into five business profiles, served by its own API.

The profile	What the agent can do
Read	Browse a repository, a history, a diff, a blame
Analyse	Run an analysis, read the findings, turn them into issues
Diagnose	Open the logs of a failed run and say what broke
Act	Retry a job, approve a deployment, roll back
Track	Create an issue, move it forward, log time spent

None of these five profiles grants a shell or filesystem access. There is no machine to designate, no working directory to open, no system account to create. The agent sees what the API exposes, under the identity of the person driving it, and nothing else. What that changes: the assistant becomes usable in production, not only on a developer workstation.

Three reasons to choose kForge

The multi-tenancy nobody else does

This is not a configuration option nor a split by projects: it is in every table and every query. Each record carries its client identifier, filtered on every request from the authentication token. A developer of your client A never sees that client B exists — not its repositories, not its pipelines, not its metrics. To serve twelve isolated clients your competitors install twelve times; you install once.

Your code never leaves, not even your application servers

kForge never runs git itself. History, diffs, cloning, search: everything is delegated to an agent, on your machines. The application servers are stateless, with no repository mounted and not even the git binary installed. For a security officer, that is one identified surface, inside the perimeter.

Nothing is reinvented, so nothing is maintained twice

No in-house scheduler, no in-house runner, no in-house artefact store: kForge compiles your pipelines down to the Kore platform, which executes them. Less code, fewer updates, less surface to audit — and one authentication, audit and notification chain shared across your whole information system.

Discover the Kore platform

Who it is for

Service companies, integrators, managed-service providers

You operate the development tooling of several clients. One installation serves them all, with per-client quotas and billing that follows the number of clients, not the number of developers. You can also redistribute kForge to your own clients under your contract.

Regulated industries, public sector

Self-hosted, off-network if required, in no proprietary format. The whole chain is traceable — from a commit to the issue it resolves, from the issue to the deployment, from the deployment to the metric — and readable at audit time without manual reconstruction. Perpetual licence available.

What comes with it, and what is not there

A sales pitch that does not state its limits makes you discover them in the second month. Here are ours, now.


Repositories read today	local, GitHub, GitLab. Bitbucket and Azure DevOps are not connected — it is planned, it is not done.
Commit detection	A few seconds on a local repository, around thirty on a remote one. Instant detection is under development.
Extensions	No marketplace. We will never have the fifteen thousand Jenkins plugins — and a plugin you do not install is a plugin you do not audit.
Prerequisite	kForge runs on the Kore platform, which provides authentication, agents and execution. It is billed separately, and it also carries everything we will deliver you next.

Start with a code audit — free

Give us access to one repository. We run the analysis, we triage the results, and we hand you a written report: what we found, what we set aside, and why. You leave with a usable document, whether or not the rest happens with us.

Thirty minutes are enough to tell whether kForge answers your situation — or does not. We will say so plainly either way, including if your repositories sit on a forge we do not read yet.
Technical documentation and access to a multi-client demonstration instance on request.

Get in touch