canonical: https://jentic.com/apis/daystruct.ai/daystruct

# Daystruct API

The Daystruct API provides read-only access to provenance-backed evidence about entities, including canonical facts, historical observations, relationships, and the sources behind each claim. It resolves software compatibility, vulnerability exposure, and support-lifecycle questions from versioned databanks, and lets developers discover, acquire, and version-pin reusable capability kits with verified compatibility locks. It also manages developer-owned agent identities linked to an API key; registered capabilities are declarations only, as the API has no task-dispatch surface.

## For AI agents

Read provenance-backed facts about entities, look up software vulnerabilities and compatibility, and acquire version-pinned capability kits. Manages developer-owned agent identities across 82 endpoints.

## Scope

Does not route tasks to agents, dispatch jobs, or execute capabilities for you. Use for reading provenance-backed evidence and acquiring versioned capability kits only.

## Capabilities

- Read provenance-backed facts, historical observations, aliases, and relationships for an entity
- Look up software compatibility claims, vulnerability exposure, and support lifecycle from versioned databanks
- Discover capabilities on the network and acquire a version-pinned source kit with its downloadable artifact
- Resolve capability bundles with version-pinned members and check that a set of capabilities works together
- Register and update developer-owned agent identities linked to an API key
- Consume a durable canonical change feed with field-level change events and evidence conflicts

## Use cases

### Grounding an AI Agent in Verified Evidence

An AI agent connected to Daystruct through Jentic can resolve canonical facts and their provenance before answering, rather than relying on unsourced recall. It can read an entity's facts, aliases, and relationships and trace each claim to its source, so the agent's output cites where a value came from. Resolved values are presented as best-supported current interpretations, which the agent can surface honestly instead of as absolute truth.

Example prompt: Read the canonical facts and provenance for a given entity id, then summarise the answer with the source behind each value

### Software Vulnerability and Support Checks

Daystruct's versioned databanks let a developer or agent resolve which known vulnerabilities affect a specific package version, whether a product version is still supported as of now, and how software compatibility claims line up. This turns scattered software evidence into direct lookups for dependency review and upgrade planning without scraping advisories by hand.

Example prompt: Resolve the exposure for version 2.14.1 of a named package and report any known vulnerabilities that affect it

### Acquiring Reusable Capability Kits

Developers can discover capabilities published on the Daystruct network, inspect a capability profile by any of its names, and acquire a specific source implementation version with a downloadable artifact. Bundles resolve their version-pinned members, and compatibility checks and verified locks confirm a chosen set works together before it is pulled into a project.

Example prompt: Look up a capability profile by name, acquire its latest inspected version, and download the source artifact for this account

### Developer-Owned Agent Identity Registration

Daystruct lets developers register durable agent identities linked to an API key and declare the capabilities each identity supports. Registered agents are declarations only and are not routable, so this manages identity and capability metadata rather than dispatching work. Identities can be listed, read, and updated under the same key that created them.

Example prompt: Register a new developer agent identity with its declared capabilities, then read it back to confirm the link to the API key

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/v1/entities/{id}/facts` | List canonical facts and provenance for an entity |
| GET | `/api/v1/databanks/{slug}/exposure` | Resolve vulnerabilities affecting a package version |
| GET | `/api/v1/software/claims` | Query version-scoped software compatibility claims |
| GET | `/api/v1/capabilities` | List capabilities published on the network |
| POST | `/api/v1/capabilities/{ref}/acquire` | Acquire an inspected source implementation version |
| POST | `/api/v1/compat/check` | Check whether a set of capabilities works together |
| POST | `/api/v1/agents/register` | Register a durable developer agent identity |
| GET | `/api/v1/events` | Consume the durable canonical change feed |

## Key resources

- **Entities** — Read entities with canonical facts, provenance, history, aliases, and relationships
- **Databanks** — Resolve vulnerability exposure, software support lifecycle, model constraints, and schemas by slug
- **Capabilities** — Discover, inspect, acquire, and download version-pinned capability source kits
- **Compatibility** — Check capability sets, resolve bundles, and read verified compatibility locks
- **Agents** — Register, list, read, and update developer-owned agent identities linked to an API key
- **Change feed** — Consume the durable canonical change feed, field-level changes, and evidence conflicts

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 44 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 60 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 25 / 100
  - Agent Usability: 89 / 100
  - Security: 35 / 100
  - AI Discoverability: 53 / 100
- **View full report:** https://jentic.com/apis/daystruct.ai/daystruct/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Daystruct by hand means handling its bearer API-key auth plus basic operator credentials for the monitor surface, its scoped permissions, and its per-call pricing quotes. Through Jentic you install once, import Daystruct from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Daystruct is mostly read-only evidence, and its write paths (registering agent identities, submitting requests, acquiring paid capabilities) are separate operations. A rule can let your agent read entities, facts, and databanks while identity registration and capability acquisition stay out of its reach. You choose the operations it may call, so nothing that spends credits runs unless you add it.
- **Credential handling:** Your Daystruct API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'look up vulnerabilities for a package version' or 'read an entity's provenance', and Jentic returns the matching Daystruct operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Snyk API** — Dedicated software vulnerability and dependency scanning, complementing Daystruct's read-only exposure databanks.
- **GitHub API** — Source of the open-source repositories Daystruct's refinery draws capability candidates from.
- **GitLab API** — DevOps platform with its own package and dependency registry, versus Daystruct's capability-kit network.

## FAQ

### Is there a Daystruct MCP server?

Daystruct exposes an MCP endpoint of its own, but you don't need to wire up a separate MCP server to use it from your agent. Jentic connects Daystruct directly from the API Directory: import it, store your API key once, and your agent calls the evidence, databank, and capability operations, discovered on demand so no extra tool definitions bloat its context.

### Can I limit what my agent is allowed to do with Daystruct?

Yes. Write a rule that allows the evidence and databank read operations but not agent registration or capability acquisition, so the agent can ground its answers in provenance-backed facts without spending credits or changing your account, and every call it makes is logged.

### What authentication does the Daystruct API use?

Per its OpenAPI spec, the Daystruct API uses a bearer API key in the ds_live_ format for registered-agent and request operations, with HTTP basic operator credentials for the monitor refinery surface. Public evidence reads are allowed without a key, and keys are scoped in the developer portal. Through Jentic the key is stored encrypted by your own Jentic One instance and injected only at call time.

### Can I look up software vulnerabilities with the Daystruct API?

Yes. The databank exposure operation resolves which known vulnerabilities affect a specific version of a package, the vulnerability lookup reads one vulnerability by its identifier, and the support operation reports whether a product version is still supported as of now. These are read-only lookups against version-scoped databanks.

### What are the rate limits for the Daystruct API?

The OpenAPI spec does not specify request-rate limits; instead it publishes per-call prices and a margin-policy quote through the pricing operation, and request operations return a credit quote before you commit. Check the developer portal at daystruct.ai/portal for current pricing and quota details.

### How do I ground my agent in provenance-backed evidence through Jentic?

Call the entity facts operation to read canonical values and their sources, or the databank operations for software and vulnerability questions, then have the agent cite each source in its answer. In Jentic, search for 'look up provenance-backed evidence about an entity', store your API key once, and the agent runs the read. To run it on your own infrastructure, install Jentic One from its GitHub repo.