SkillAgentSearch skills...

ontoly

Open-source Software Intelligence Platform. Deterministic verification, structural PR reviews, interactive graph explorer, and proactive intelligence — powered by the Software Graph. 41 node types · 32 relationships · 120+ checks.

Install / Use

claude mcp add 0xsarwagya -- npx -y github:0xsarwagya/ontoly

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

83/100

Supported Platforms

Claude Code
Claude Desktop

Our assessment of ontoly

ontoly scores 83/100 on our quality scale, 2990th of 4,705 Development & Engineering skills we index.

Its MCP Server is 21 KB long, well organised into 29 sections with 22 code examples: a thorough specification that gives an agent plenty to work with.

It has 3 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
3/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 4 days ago, so ontoly is actively maintained.
  • It is released under AGPL-3.0, a copyleft license: you can use it, but modified versions you distribute must carry the same license.
  • Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-16. Automated pattern scan on 2026-11-16. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

ontoly compared with similar skills

All 4 of these similar skills score higher than ontoly; compare them before choosing.

SkillScoreStarsUpdatedFormat
ontoly (this skill)by 0xsarwagya8334d agoMCP Server
taste-skillby Leonxlnx100117.0k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.4k9d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.9ktodayCLAUDE.md

Frequently asked questions

How do I install ontoly?
Run claude mcp add 0xsarwagya -- npx -y github:0xsarwagya/ontoly. The install tabs above show the steps for each supported agent.
Which AI agents does ontoly work with?
It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
Is ontoly safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is AGPL-3.0-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is ontoly still maintained?
The repository was last updated 4 days ago, so ontoly is actively maintained.

Ontoly

Release Verification npm install License: AGPL-3.0 TypeScript

Ontoly is a JavaScript- and TypeScript-native software intelligence engine that turns source code into a deterministic Software Graph.

Developer tools should not have to rediscover the same repository structure over and over. Ontoly builds one shared semantic representation that agents, MCP servers, SDK generators, documentation tools, architecture tools, static analysis, and IDEs can query without repeatedly searching files or rebuilding partial AST context.

Ontoly builds understanding. It does not answer questions, call language models, generate embeddings, or make probabilistic guesses.

Status

Ontoly v1.0.0 is the first stable release. Current release: v1.3.5.

The public contract is frozen, and the repository includes:

  • a Software Graph specification
  • a deterministic compiler pipeline
  • a JavaScript and TypeScript semantic frontend powered by the TypeScript Compiler API
  • a query engine
  • MCP capabilities
  • deterministic Enhancers for artifact generation
  • a derived Semantics artifact for feature ownership, intent vocabulary, and concept graphs
  • a derived History artifact for ownership, hotspots, co-changes, churn, and drift
  • portable Agent Skills
  • validation and semantic evaluation infrastructure
  • release gates for docs, packaging, skills, examples, and regression checks

Links

What Ontoly Is

Ontoly is the semantic layer between a software repository and every tool that needs to understand it.

Repository
  -> Compiler Frontends
  -> Semantic Model
  -> Software Graph
  -> Enhancers
  -> Semantics
  -> Query Engine
  -> MCP, Skills, SDKs, Docs, IDEs, Analysis

The Software Graph is the product. Everything else is a consumer, plugin, pass, or validation layer around it.

What Ontoly Is Not

  • Not a chat interface.
  • Not a coding agent.
  • Not a copilot.
  • Not vector search.
  • Not an embeddings pipeline.
  • Not hosted SaaS.
  • Not a code generator by default.
  • Not a replacement for TypeScript, ESLint, or test suites.

AI tools can consume Ontoly through MCP and Skills, but the graph never depends on AI output. Every LLM-facing use of Ontoly must go through LLM Enhancement so graph evidence, confidence, and fallback rules stay explicit.

Why Software Graphs

Most developer tools redo the same expensive work:

  • agents search files
  • documentation tools parse symbols
  • architecture tools rebuild dependency graphs
  • SDK generators infer API shapes
  • static analyzers rebuild call and import relationships

Ontoly turns that repeated work into a reusable graph:

  • deterministic IDs
  • graph-native diagnostics
  • explicit provenance
  • stable serialization
  • query indexes
  • semantic concept indexes
  • validation reports
  • extension metadata

The goal is simple: every tool that needs software understanding should first ask whether Ontoly already knows.

Quick Start From Source

Use this path when building from source.

git clone https://github.com/0xsarwagya/ontoly.git
cd ontoly
corepack enable
pnpm install --frozen-lockfile
pnpm build

Build a graph for the included basic example:

pnpm ontoly build examples/basic

Inspect generated artifacts:

ls examples/basic/ontoly-output
pnpm ontoly inspect src/service.ts --root examples/basic
pnpm ontoly search UserService --root examples/basic
pnpm ontoly impact UserService --root examples/basic
pnpm ontoly stats examples/basic

Run the main release gates:

pnpm check-types
pnpm test
pnpm docs:check-links
pnpm skills:validate
pnpm validate:packages

Run the full gate before a release:

pnpm release:gates

Package Install

The public package names are scoped under @0xsarwagya.

Install with:

pnpm add -D @0xsarwagya/ontoly-cli
pnpm exec ontoly build .

In an interactive terminal, ontoly build without a path asks which folder to index. Press Enter for the current directory, paste a relative, absolute, or ~/ path, or pass the path explicitly:

pnpm exec ontoly build
pnpm exec ontoly build apps/api
pnpm exec ontoly build --no-prompt

If npm is unavailable in your environment, use the source checkout flow above.

Build Artifacts

ontoly build <repository> writes the rich ontoly-output/ bundle by default:

ontoly-output/
  SoftwareGraph.json
  manifest.json
  coverage.json
  quality.json
  semantic-model.json
  reports/
    architecture.json
    api.json
    dependencies.json
    configuration.json
    frameworks.json
    workspace.json
  nodes/
    by-type/
  relationships/
    by-type/
  communities/
    communities.json
    community-000.json
  html/
    graph.html
    architecture.html

The output bundle is deterministic and intended for humans, agents, websites, release artifacts, and debugging Ontoly's own understanding.

For the compact cache-style artifact directory, pass --output .ontoly:

ontoly build . --output .ontoly
.ontoly/
  SoftwareGraph.json
  diagnostics.json
  indexes.json
  metadata.json
  statistics.json

The JSON graph is the canonical serialization format. Binary formats are intentionally out of scope until the Software Graph specification is stable.

Remote repositories can be compiled directly:

ontoly build --remote https://github.com/0xsarwagya/ontoly.git
ontoly output --remote git@github.com:0xsarwagya/ontoly.git

Remote builds clone into a temporary checkout, write relative output paths into the directory where you ran Ontoly, and record the git URL in the output manifest.

Software Graph

The Software Graph is a versioned JSON model containing:

  • repository metadata
  • nodes
  • edges
  • diagnostics
  • indexes
  • statistics
  • provenance
  • extension metadata

Core node families include modules, packages, functions, methods, classes, interfaces, type aliases, enums, routes, controllers, services, providers, configuration, environment variables, events, and resources.

Core relationship families include IMPORTS, EXPORTS, CONTAINS, CALLS, DEPENDS_ON, USES, READS, WRITES, IMPLEMENTS, EXTENDS, HANDLES, MOUNTS, INJECTS, AUTHORIZES, REGISTERED_IN, PUBLISHES, and SUBSCRIBES.

Read the canonical spec in RFC-0001.

Deterministic IDs

Ontoly assigns stable IDs so graph output can be cached, diffed, tested, and compared across builds.

Examples:

module:src/auth/service.ts
fn:src/auth/service.ts:login
class:src/auth/user-service.ts:UserService
route:POST:/login
model:User

IDs should survive rebuilds whenever the semantic identity survives.

Compiler Pipeline

The compiler is a deterministic multi-stage pipeline:

Repository Discovery
  -> Frontend Parsing
  -> Symbol Emission
  -> Semantic Model Generation
  -> Relationship Extraction
  -> Graph Construction
  -> Diagnostics
  -> Validation
  -> Indexing
  -> Serialization

Compiler frontends emit structured facts. The compiler owns graph construction. This keeps parser packages small and keeps graph compatibility centralized.

Read the architecture in RFC-0002.

Query Engine

The query engine provides deterministic graph reasoning primitives:

  • lookup by ID, name, type, file, and tag
  • neighborhood expansion
  • graph walks
  • dependency traversal
  • caller and callee lookup
  • path finding
  • impact analysis
  • filtering
  • pattern matching
  • index-backed traversal

Read the query design in RFC-0003.

Example:

import { buildSoftwareGraph } from "@0xsarwagya/ontoly-compiler";
import { createQueryEngine } from "@0xsarwagya/ontoly-query";

const graph = await buildSoftwareGraph({ root: process.cwd() });
const query = createQueryEngine(graph);

const services = query.services();
const callers = query.callers("fn:src/auth/service.ts:login");
const dependencies = query.dependencies("class:src/auth/user-service.ts:UserService");

CLI

The source checkout exposes the CLI through the root ontoly script:

pnpm ontoly --help

Common commands:

| Command | Purpose | | --- | --- | | pnpm ontoly build <repo> | Build a Software Graph. | | pnpm ontoly output <repo> | Generate ontoly-output/ with JSON reports, graph communities, and HTML explorers. | | pnpm ontoly inspect <graph-or-query> | Inspect graph artifacts or entities. | | pnpm ontoly search <concept> | Resolve natural concepts to ranked graph entities. | | pnpm ontoly find <concept> | Find symbols, acronyms, features, or configuration terms. | | pnpm ontoly locate <feature> | Locate feature-level graph touchpoints. | | pnpm ontoly evidence <query> | Generate a compact graph-backed Evidence Pack for agents and reviews. | | pnpm ontoly semantics build <repo> | Generate the derived Semantics artifact and concept graph. | | pnpm ontoly history build <repo> | Generate repository history, ownership, hotspot, co-change, and drift artifacts. | | pnpm ontoly ownership <symbol> | Inspect deterministic Git-derived repository ownership. | | pnpm ontoly hotspots | List high-churn/high-modification graph hotspots. | | pnpm ontoly trace <symbol> | Trace graph relationships. | | pnpm ontoly coverage <repo> | Report semantic coverage. | | pnpm ontoly mcp | Start MCP capabilities. | | pnpm ontoly skills list | List packaged Agent Skills. | | pnpm ontoly skills validate | Validate skill metadata, links, templates, and examples. | | pnpm ontoly validate all | Run the validation lab. | | pnpm ontoly evaluate | Run semantic evaluation. | | pnpm ontoly leaderboard | Generate semantic leaderboard output. | | pnpm ontoly benchmark performance | Run performance benchmark reporting. | | pnpm ontoly diff base.graph head.graph | Deterministic Software Graph diff per RFC 0005. |

See docs/cli.md and docs/reference/cli.mdx.

MCP

Ontoly MCP exposes structured capabilities over the Software Graph. Capabilities validate inputs before execution and return structured diagnostics for missing, ambiguous, or unsupported requests.

When an LLM consumes Ontoly MCP responses, LLM Enhancement is mandatory. Non-LLM tools may call MCP directly, but LLM-generated answers must preserve Ontoly evidence, confidence, and fallback boundaries.

pnpm ontoly mcp --list
pnpm ontoly mcp

Representative capabilities:

  • `GraphStatisti

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars3
CategoryDevelopment
Updated4d ago
Forks1

Languages

TypeScript

Trust signals

92/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 low