Calyntro turns your Git history into a strategic map of knowledge risk, team coupling, and architectural drift — giving CTOs and Engineering Managers the quantitative foundation their decisions have been missing.
Live, read-only · MongoDB open-source repository · No login required
The Problem
Without objective metrics from your Git history, knowledge silos, bus factor risk, and architectural drift stay invisible — until they cause an incident or a costly re-organisation.
Features require coordination across teams because the work follows hidden knowledge boundaries, not org chart lines. Every cross-team dependency is coordination overhead — and it compounds silently over years.
When a key engineer leaves, their understanding of critical modules leaves with them. In professionally maintained codebases, a single developer often holds exclusive knowledge of hundreds of files — the bus factor risk only surfaces when something breaks.
High churn plus rising complexity equals the next incident. Without objective metrics, these hotspot files stay off the radar until they cause missed sprints, build-time explosions, or production outages.
Why Calyntro
Tracks who owned code when it was written — not just who is on the team today. Captures the knowledge that org charts and current rosters miss entirely.
Coupling, ownership, knowledge risk — not fragmented across three tools. One platform that connects what your code does to who can maintain and evolve it.
Works on any repository you can clone. No agents, no integrations, no API tokens. If you have a Git history, Calyntro can analyse it — in any language, on any hosting platform.
Team restructuring, release risk assessment, offboarding — all have quantitative answers in your Git history. Calyntro surfaces them so you walk into conversations with evidence, not opinions.
No firewall exceptions. No third-party data processing agreements. GDPR-friendly by design — fully air-gap compatible.
Flat rate regardless of team size or number of repositories. No per-seat fees that scale against you as your organisation grows.
Methodology & Evidence
The hotspot analysis methodology was pioneered by Adam Tornhill in Your Code as a Crime Scene and Software Design X-Rays. Calyntro automates it — and extends it with temporal ownership and cross-team coupling analysis.
From the live demo — MongoDB open-source repository, analysed with Calyntro
src_third_party — the highest-churn module.Early Adopter
"A 60-person embedded software team used Calyntro to surface knowledge concentration in their Qt/QML codebase — ahead of a planned team restructuring and CI/CD pipeline overhaul."
Why Calyntro exists
Working with a 56-developer organisation through a team redesign, I found that no single tool combined code ownership, change coupling, and knowledge silos in one place. I kept writing custom scripts to get the numbers I needed. Calyntro exists so that doesn't have to be the workaround.
— Karl-Heinz Reichel, Founder
For engineering organisations where code confidentiality is non-negotiable, Calyntro's self-hosted architecture is the only responsible choice. No firewall exceptions. No DPA negotiations. No cloud processing of your intellectual property.
Features
Each view answers a different question your Git history has already answered — you just haven't had the tool to ask it.
Five-dimension risk heatmap across all modules — complexity, churn, silo risk, absolute change frequency, and file age. Critical areas are impossible to miss.
Explore Hotspot Analysis → Strategic PlanningComplexity × Churn scatter plot with four quadrants: Hotspot, Non-critical, Legacy risk, Healthy. The evidence base your roadmap conversations have been missing.
Explore Scatter Analysis → Knowledge RiskComplete ownership map with bus factor KPIs, developer breakdown, top-risk files, and a month-by-month silo ratio trend.
Explore Knowledge Risk → Team StructureChange coupling reveals hidden dependencies between modules. Cross-team coupling makes coordination overhead measurable — and reducible.
Explore Change Coupling → Org TransformationTeam Health Table, Module Ownership Heatmap, and Coordination Matrix — three views that map your team topology to your codebase and surface contested ownership before it becomes a crisis.
Explore Team Architecture →Use Cases
The decisions that define your team's productivity, your architecture's health, and your delivery reliability — all have quantitative answers in your Git history.
Calyntro maps which files and modules a developer exclusively owns, surfaces their temporal ownership footprint, and quantifies the knowledge risk before the notice period ends.
Change coupling data reveals which modules are modified together regardless of team assignment. The evidence base for a data-driven team topology decision, not an org-chart opinion.
Combine silo risk scores with churn data to identify which components in an upcoming release are high-risk — and who the sole owner is.
Trend analysis tracks Cognitive Complexity and LOC over time per module. A rising complexity curve in a high-churn module is an early warning signal — not a post-mortem finding.
Conway's Law drift is measurable. Change coupling and ownership data reveal where your current team boundaries generate coordination overhead — the quantitative foundation for a Team Topologies-driven reorganisation.
How Calyntro fits your toolstack
Static analysis tools tell you where your code has problems today. Calyntro tells you whether your team is structured to fix them — and who still understands the code well enough to do it.
Get started
Explore and deploy on your own, or work with us directly. Both paths give you the same quantitative foundation; the difference is how much you want us involved.
The live demo runs a full analysis of the MongoDB open-source repository. Get a realistic picture of the insights before deciding whether to engage.
We run the analysis on your infrastructure, walk through the findings with your team, and leave you with concrete recommendations — not a dashboard hand-off.
FAQ
The initial deployment is straightforward — Calyntro runs as a Docker stack and the containers are up in minutes. The meaningful setup work is the first configuration: mapping your directory structure to logical modules, defining teams, and resolving author aliases. That typically takes a few hours and benefits significantly from a guided session. Most customers get to first meaningful results within a half-day engagement.
Calyntro is Git-native and works with any repository you can clone locally — GitHub, GitLab, Bitbucket, Azure DevOps, Gitea, or self-hosted bare repos. No API tokens or hosting-platform integration required: it reads the local Git history directly.
No. All analysis runs entirely inside your own infrastructure. Calyntro only reads Git metadata — commit hashes, file paths, author names, timestamps, and line counts. No source code is read, transmitted, or stored outside your environment. It is fully air-gap compatible.
Code ownership, change coupling, knowledge silos, and churn metrics are language-agnostic — they derive from Git history, not source code. Complexity metrics (cyclomatic and cognitive) are computed by rust-code-analysis and cover C, C++, C#, Java, JavaScript, TypeScript, Python, Rust, Go, Kotlin, and more. Files in unsupported languages simply omit complexity metrics; all other metrics still apply.
The annual license (from €5,000/year) covers unlimited repositories, unlimited users, and all current features — with no per-seat or per-author fees. It includes access to new releases for the license period. Consulting engagements and guided onboarding are quoted separately per engagement.
Yes, in two ways. The live demo runs against the MongoDB open-source repository — no login or setup required. For a trial on your own codebase, get in touch: we typically run a first analysis as part of an initial engagement before any license conversation.
Calyntro is licensed annually from €5,000/year — a flat rate regardless of team size, number of repositories, or number of users. There are no per-seat or per-author fees. The license covers all current features and access to new releases throughout the license period. Consulting engagements and guided onboarding sessions are scoped and quoted separately. Get in touch to discuss what makes sense for your organisation.
Mostly yes, with one honest caveat. Ownership, change coupling, churn, and knowledge silo metrics are derived from Git metadata — commit author, file path, timestamp, and line counts. These work regardless of whether code was written by a human or an AI assistant. Complexity metrics (cyclomatic and cognitive) run on the source code itself and are equally unaffected. The caveat: if AI-assisted commits are consistently made under a single author identity (e.g. always the same developer triggering Copilot), ownership signals for that author will be inflated relative to their actual understanding. Calyntro surfaces this as a high ownership concentration — which is technically accurate and worth knowing.
Three meaningful differences: (1) Temporal ownership — Calyntro tracks who owned code when it was written, not just recent activity, which captures knowledge that current team rosters miss entirely. (2) Open REST API on all deployments — CodeScene's API is restricted to on-premise licenses; Calyntro's API is fully open regardless of deployment. (3) No per-author pricing — cost stays flat as your team grows. At roughly 40–60% of CodeScene's annual cost for comparable team sizes, it's also a straightforward budget argument.
Get Started
Calyntro surfaces them. Get in touch to discuss what a codebase and team-structure analysis would look like for your organisation.
Live, read-only · MongoDB open-source repository · No login required