Tools

Tools give AI the ability to retrieve real-time data and take actions on your infrastructure. They bridge the gap between the static ontology and the dynamic world of your systems.

The Ontology + Tools Model

SixDegree separates concerns between what exists (the ontology) and what's happening (tools):

Ontology	Tools
Long-living resources	Ephemeral data & actions
Repositories, deployments, services	Pull requests, incidents, vulnerabilities
Discovered automatically	Called on-demand by AI
Graph structure with relationships	Real-time API calls

This separation is powerful: the ontology provides context and relationships, while tools provide current state and the ability to act.

Entity-Bound Tools

Most tools in SixDegree are entity-bound—they operate on a specific entity.

The OOP Analogy

Think of it like object-oriented programming: entities are objects, and tools are methods that belong to those objects.

// In OOP, methods belong to objects
repository.getPullRequests()
repository.createIssue(title, body)

// In SixDegree, tools belong to entities
github.getPullRequests(repository)
github.createIssue(repository, title, body)

Just as you wouldn't call getPullRequests() without knowing which repository, you can't call a SixDegree tool without the entity context. The entity is the anchor that gives the tool meaning.

Reading Ephemeral Data

Tools retrieve real-time data about an entity:

github.getPullRequests(repo)        → PRs for that repository
snyk.getVulnerabilities(project)    → vulnerabilities for that project
pagerduty.getIncidents(service)     → incidents for that service
kubernetes.getPods(deployment)      → pods for that deployment

Taking Actions

Tools can also take actions on entities:

github.createIssue(repo, title, body)           → creates issue on repo
slack.postMessage(channel, text)                → posts to channel
pagerduty.acknowledgeIncident(service, id)      → acknowledges incident

The entity is always the anchor. Tools don't operate in isolation—they operate in the context of an entity from your ontology.

Why This Matters

Explicit Correlation

Because tools are entity-bound and relationships exist in the ontology, AI can connect data across systems without guessing:

User: "Show me our Log4Shell exposure"

1. AI queries ontology → gets SnykProject entities (with relationships)
2. For each project, AI calls snyk.getVulnerabilities(project)
3. AI traverses relationships:
   SnykProject --scans--> GitHubRepository
   GitHubRepository --deployed_as--> K8sDeployment
   GitHubRepository --owned_by--> Team
4. AI assembles answer:
   "47 repos affected, 32 in production, owned by 5 teams..."

No pattern matching or identifier guessing needed. The relationships are already established in the ontology.

Clean Separation

This model keeps things simple:

• Molecules discover entities and create intra-molecule relationships
• Rules establish inter-molecule relationships across different systems
• Tools operate on entities to get data or take actions
• AI traverses the graph and calls tools as needed

Molecules are intentionally isolated—they only create relationships between entities they discover themselves. A GitHub molecule creates GitHubRepository --owned_by--> GitHubOrganization relationships. A Snyk molecule creates SnykProject entities but doesn't need to understand GitHub.

Cross-system relationships like SnykProject --scans--> GitHubRepository are established through rules. This keeps molecules loosely coupled and lets you customize how your systems connect.

Tool Categories

1. Entity-Bound Tools (Most Tools)

Provided by molecules. Operate on specific entities.

Tool	Entity	Operation
snyk.getVulnerabilities(project)	SnykProject	Read vulnerabilities
github.getPullRequests(repo)	GitHubRepository	Read pull requests
github.createIssue(repo, ...)	GitHubRepository	Create issue
slack.postMessage(channel, ...)	SlackChannel	Post message
pagerduty.getIncidents(service)	PagerDutyService	Read incidents

2. Generic Utilities (Rare)

Platform-level helpers that don't operate on entities:

• display_spreadsheet — render data as a table
• format_markdown — format output for display

These are rare and typically used for presentation.

Using Tools Through AI

You don't call tools directly—AI decides when to use them based on your questions:

"What PRs are open on the api-service repo?" → AI finds the repository entity, calls github.getPullRequests(repo)

"Are there any critical vulnerabilities in production?" → AI finds production deployments, follows relationships to Snyk projects, calls snyk.getVulnerabilities(project) for each

"Post in #engineering-alerts about the outage" → AI finds the Slack channel entity, calls slack.postMessage(channel, text)

Building Tools

Tools are provided by molecules. When you build a molecule, you can expose tools that operate on the entities you discover.

See Building MCP Tools for implementation details.

Next Steps

• Entities & Relationships — The building blocks of the ontology
• Molecules — How entities and tools are provided
• Rules — How relationships are established