Development platform

koraiForge — Multi-client software forge and continuous integration

A single installation for the development tooling of all your clients: one upgrade instead of one per client. 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.

Natively multi-tenantSelf-hostedUsable by AI agents, without shell access

The problem

Forges and continuous-integration engines on the market are built for a single 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 koraiForge does

The four products in a single application, with one client model and one installation. Your repositories stay where they are: koraiForge 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.

  • Change tracking: the agent watches the directory of a local repository; polling and signed webhooks (GitHub, GitLab) cover remote ones.
  • An issue can be escalated to the parent tenant — from a client to the tenant serving it, for instance — if that parent allows escalations; tenants following it are notified of its status changes.
  • A forge issue becomes a koraiForge issue, with its labels and its history.
  • A commit links to an issue, and the issue shows the commits that resolved it.
Projects, and the repositories attached to them
Aggregated repositories: GitHub, GitLab and local side by side
Forge issues, on the same screen as the code

From ideas to issues, and from findings to risks

Tracking does not stop at the issues mirrored from the forges. Ideas are filed in backlog lists with their target version; issues are read as a list, a kanban board, a roadmap, a timeline or a calendar; and a risk register places them on a probability × impact matrix, with their initial and residual level and the state of their review.

  • Service-level commitments apply to issues, and a public intake form creates an issue without an account.
  • A reminder can be set on any item, and everyone finds theirs on a “My reminders” page.
  • Issues are mirrored from one koraiForge instance to another — a provider’s and its client’s, for instance — according to declared synchronisation rules.
Ideas, filed by backlog and target version

Continuous integration, nothing reinvented

Stages, jobs in a dependency graph, matrices, execution in a shell, a container, Kubernetes or over SSH. Nine trigger types, including periodic execution of a sandboxed script and URL polling whose state survives 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. Reversibility is built in from the start.
  • The page of a run shows its status, the map of its stages and jobs, each job's console with collapsible steps, and the dependency graph with the actual order in which jobs ran.
  • A run's artefacts are browsable on its page: files in the archive, image thumbnails, download, and a QR code to open the file on a phone. An artefact can be restricted to those who approve releases.
  • koraiForge has no scheduler of its own, no runner of its own, no artefact store of its own: it compiles your pipelines down to the koraiCore platform, which executes them.
Pipelines, their runs, and the metrics that follow from them
One run: its stages, its console, its artefacts

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 suppressed or deleted 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 a single action, without duplicates.

  • A triage tool, not a counter: the value lies in triaging findings, and that is where the effort goes.
  • 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 focuses on verification rather than volume.
The findings of each analysis, by severity and by analyser

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.
  • A page of composable charts tracks pipeline runs and deployments over time, starting from ready-to-add templates.
The four metrics, and their performance level when the data allows it
Deployments and rollbacks tracked over time

An AI that works on your code without access to 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 question is quickly settled. koraiForge takes a different approach: the application exposes 68 tools to an agent, grouped into five business profiles, served by its own API.

The profileWhat the agent can do
koraiForge (overview)Find projects, repositories, pipelines, issues and findings — read-only
RepositoryBrowse a repository: history, branches, files, diffs, blame, issues linked to commits
CI / PipelinesRead the logs of a failed run, retry a job, trigger, approve or cancel a run, roll back a deployment
Code analysisRun an analysis, verify findings against the code, turn them into risks or issues
IssuesCreate, update, comment on and move an issue forward, link it to commits, set and follow up reminders, view and 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. As a result, the assistant becomes usable in production, not only on a developer workstation.

What koraiForge changes

Native multi-tenancy

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 stays on your premises

History, diffs, cloning, repository watching: reading your repositories goes through an agent installed on your machines. Your code stays on your servers, and repository access goes through one identified point, inside your perimeter — which is what a security officer asks to be able to name.

Nothing is reinvented, so nothing is maintained twice

No in-house scheduler, no in-house runner, no in-house artefact store: koraiForge compiles your pipelines down to the koraiCore 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 koraiCore platform

Who it is for

Service companies, integrators, managed-service providers

You operate the development tooling of several clients. One installation serves them all.

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.

Use cases

Continuous integration for all your clients

Software forges and continuous integration tools are designed for a single organisation. Serving twelve isolated clients means installing, upgrading and administering twelve platforms.

Read the page

Measuring DORA metrics from actual deployments

The delivery metrics presented to management are often rebuilt in a spreadsheet, from only part of the deployments.

Read the page

An AI assistant on your code, without machine access

Most development assistants assume command-line access and a machine to work on. For many organisations, that is what makes AI unacceptable.

Read the page

Frequently asked questions

What is koraiForge, and who is it for?

koraiForge is a development platform published by Koraisoft: it brings git repository tracking, continuous integration, code analysis, issues and DORA metrics together in a single multi-tenant application, installed on your servers. It is aimed at organisations that equip several isolated entities: service companies, integrators, managed-service providers, software vendors serving several clients, groups with subsidiaries. Each client is an isolated tenant within the same installation.

Does koraiForge replace GitHub or GitLab?

Your repositories stay where they are — GitHub, GitLab or your own servers — and code review and merging keep happening there. koraiForge aggregates them, mirrors their issues and pull requests for reading, and can create or update an issue and comment on the forge. What it brings together is the tooling set beside them: continuous integration, code analysis, deployment metrics.

Is koraiForge self-hosted? Where are repositories read?

Yes, koraiForge installs on your servers, on top of the Koraisoft koraiCore platform, which provides authentication, agents and pipeline execution; data is stored in PostgreSQL. History, diffs, cloning and repository watching go through a koraiCore agent installed on your machines: your code stays with you.

How much does koraiForge cost?

koraiForge pricing is under review: contact Koraisoft to discuss it.

Why bring CI, analysis, issues and metrics into one place?

Because a service company serving several clients assembles that tooling once per client. koraiForge holds it on a single client model: one installation for several isolated clients, DORA metrics computed on deployments launched by pipeline as well as from the command line, and a pipeline export to GitHub Actions format if you leave.

How can I try koraiForge?

The simplest way is to write to Koraisoft through the Contact page, describing your situation: we will look together at whether koraiForge can fit.

Talk about your development tooling

Equipping several clients or entities with development tooling? Write to us and we will look together at whether koraiForge can fit.

Contact us

Our products evolve continuously. The features, screens and characteristics shown on this page describe their state at the time of publication: they may change, be modified or be withdrawn without notice, and do not constitute a contractual commitment.

The screenshots on this page and the online demo run on fictional, deliberately small datasets: they illustrate only part of what the product does, and some features are limited or switched off in the demo environment.