Introduction
Since.dev is a self-healing software platform that turns supported API, SDK, and model changes into repair PRs. It watches dependencies and helps teams keep code moving.
What is Since.dev?
Since.dev is a self-healing software service for developers who depend on external APIs, SDKs, models, and packages. The core idea: your code did not change, but everything under it did. Supported upstream changes can break builds or create silent failures. Since.dev connects to a GitHub repository, monitors supported dependencies, detects changes, and prepares draft repair PRs. It focuses on API changes, SDK changes, model changes, and documented compatibility updates. This makes dependency monitoring more actionable. Instead of only alerting teams, Since.dev turns a supported change into a focused patch that uses existing CI. It also provides World State verification so AI agents can check assumptions against recorded observations. Since.dev suits individual developers, small teams, agencies, and platform teams. It matters because external providers move fast, and manual tracking does not scale. A repair PR gives teams a clear starting point without hiding source evidence.
Key Features of Since.dev
Detect Supported API, SDK, and Model Changes
Since.dev watches supported public sources for API changes, SDK releases, and model updates. It records observations and links them to original sources.
Prepare Repair PRs Automatically
When a supported change affects connected code, Since.dev can prepare a draft repair PR. These repair PRs use the repository's existing CI and stay under team review.
Verify Agent Assumptions with World State
Since.dev offers World State checks so AI agents can compare assumptions with the latest recorded observation. If something differs, the agent receives evidence to review.
Connect Through MCP, HTTP API, or Webhooks
Teams and agents can read, process, and acknowledge changes through MCP, HTTP API, or signed webhooks. This supports automated workflows without locking users into one tool.
Review Coverage and Source Evidence
Since.dev shows supported sources and keeps upstream evidence with each repair. Users can inspect coverage before creating a watch and understand why a change matters.
Work with Existing CI and Revisions
Draft PRs run with the checks already in place. Users can request a revision on the same PR and review the updated patch.
Use Cases for Since.dev
Keeping Applications Stable After API Changes
When a documented API endpoint moves or is deprecated, Since.dev can trace affected calls and prepare a supported migration. This reduces manual search time.
Maintaining SDK and Model Dependencies
Teams that rely on fast-moving SDKs or AI models can use Since.dev to monitor releases and compatibility notes. It helps turn model changes into reviewable code updates.
Giving AI Agents a Reality Check
AI agents often act on assumptions about package versions or provider conditions. Since.dev provides World State verification so agents can check recorded facts before acting.
Managing Multiple Repositories for Agencies
Agencies and studios can connect several repositories and monitor dependencies without hand-checking every package. Paid plans remove dependency count limits.
Reviewing Public Package and API Changes
Anyone can browse package and API changes with links to original sources. This makes Since.dev useful for research, planning, and dependency monitoring.
How to Use Since.dev
- Start a free account and connect a GitHub repository.
- Allow Since.dev to detect supported public dependencies automatically, or adjust the monitored list.
- Review detected API changes, SDK changes, or model changes in the dashboard.
- Inspect the affected code and the draft repair PR prepared by Since.dev.
- Use the repository's CI, request a revision, or close the PR if it does not fit. Since.dev never merges or deploys.
- For agent workflows, connect through MCP, HTTP API, or signed webhooks and catch up from the last acknowledged update.
Target Audience for Since.dev
- Individual developers who maintain dependency-heavy projects
- Small teams that want automatic repairs and draft PRs
- Agencies and studios managing several applications
- Platform engineers responsible for many repositories
- AI agent builders who need World State verification
- Engineering teams that rely on public APIs, SDKs, and models
Is Since.dev Free?
Since.dev offers a free plan and two paid plans. Paid plans require your own AI provider key and bill AI usage directly through that provider. Free includes AI for the first eligible repair PR each month.
| Plan | Price | Features |
|---|---|---|
| Free | $0/month | 25 analysis credits, 1 connected repository, 50 monitored dependencies, 10 World State watches, 1 draft repair PR per month, 100 verification calls, 1 workspace member |
| Pro | $49/month or $490/year | Bring Anthropic or OpenAI key, 5 repositories, no dependency count limit, 150 World State watches, automatic repairs and draft PRs, 500 verification calls, 3 workspace members |
| Studio | $149/month or $1,490/year | Bring Anthropic, OpenAI, or AWS Bedrock, 15 repositories, no dependency count limit, 500 World State watches, automatic repairs and draft PRs, 2,000 verification calls, 10 workspace members |
Enterprise options are available through contact. The free plan is best for trying dependency monitoring and repository impact. Pro and Studio add automatic repairs and more capacity for teams.
Since.dev's Pros and Cons
| Aspect | Pros | Cons |
|---|---|---|
| Pricing | Free plan available; paid plans scale for teams | Pro and Studio require an external AI provider key for some features |
| Features | Detects API, SDK, and model changes; prepares repair PRs; supports agents | Repairs cover small documented compatibility fixes, not routine version bumps |
| Workflow | Uses existing CI; keeps revisions on the same PR; never auto-merges | Automatic repairs are limited to supported sources and eligible changes |
| Verification | World State checks give agents recorded evidence | Unknown results do not mean unchanged, so users must check source health |
| Coverage | Supports npm, GitHub, PyPI, Rust, OpenAPI, RubyGems, and other public sources | Private registries and sources behind a login are not covered |
Frequently Asked Questions about Since.dev
What does self-healing software mean?
Self-healing software in Since.dev starts with an upstream change. An API moves, an SDK removes a method, or a model is retired. Since.dev finds affected code and prepares supported repairs as draft PRs.
How often are sources checked?
Check frequency depends on the plan and the source. Each watch shows when it was last checked and how often it updates. Changes are detected on that schedule.
What does unknown mean?
Unknown means there is not enough recorded evidence to answer. Users should check the observation time and source health before relying on the result. Unknown does not mean unchanged.
What can I watch?
Users can start with a supported package, repository, specification, public page, or status source. Coverage is checked before a watch is created. Private registries and sources behind a login are not covered.
Does Since.dev repair my code automatically?
New paid repository connections default to automatic draft PRs. Since.dev checks impact, prepares supported repairs, and opens draft PRs. Users can choose monitor only to prepare repairs on demand. Since.dev never merges or deploys.
Can I ask for a different fix?
Yes. Users can request a revision in the dashboard or mention the installed GitHub app in a comment on the repair PR. Repository collaborators with permission can revise that repair. Since.dev updates the same PR and reruns its checks.
Since.dev Tags
Since.dev, self-healing software, repair PRs, API change monitoring, SDK change monitoring, model change monitoring, dependency monitoring, draft PRs, World State verification, MCP integration, automatic repairs, GitHub repository, AI agent verification.
