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/ontolyIf the server publishes to npm under a different name, use that package instead — check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
Development & EngineeringSupported Platforms
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.
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 foundOur 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.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ontoly (this skill)by 0xsarwagya | 83 | 3 | 4d ago | MCP Server |
| taste-skillby Leonxlnx | 100 | 117.0k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.4k | 9d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.9k | today | CLAUDE.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.
Skill content
View source on GitHubOntoly
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
- Website: ontoly.xyz
- Docs: ontoly.xyz/docs
- Agent Skills Catalog: ontoly.xyz/docs/skills
- Enhancers: ontoly.xyz/docs/enhancers
- Repository: github.com/0xsarwagya/ontoly
- Changelog: CHANGELOG.md
- Roadmap: ROADMAP.md
- Architecture: ARCHITECTURE.md
- RFC index: RFC_INDEX.md
- Governance: GOVERNANCE.md
- Third-party notices: THIRD_PARTY_NOTICES.md
- HOL Guard:
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
taste-skill
117.0kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.4kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.9kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
