Since.dev
Sign inStart free
Image

Make your software
self-repairable.

Since.dev watches your APIs, packages, SDKs, and models, then turns supported dependency changes into repair PRs.

Start free See how it works
A change becomes a way forward.
Dependency changeAn API has moved.
Supported repairA draft PR is ready.
Illustrative workflow
Reduced motion

For the dependencies behind what you build.

Imagenpm
ImageGitHub
ImagePyPI
ImageRust
ImageOpenAPI
ImageRubyGems
Since.dev featured on There's An AI For That

From outside change to inside fix

Less chasing changes.
More moving forward.

Connect your GitHub repository. See what changed, find the affected code, and review a supported repair.

A change, followed through.Interactive example
Dependency change detected

The SDK changed.
Now you know.

A scheduled check finds a release and its official migration guide.

Previously observed19.0.009:00
Latest observed20.0.010:15
Migration guide: send → messages.create

Illustrative workflow. Fictional package and observations.

Supported patches and draft PRs by Since.dev. Tests run in your repository. You choose what ships.

Your code has dependencies.
We keep an eye on them.

API contract

An endpoint moved.Your product shouldn’t have to stop.

Connect a documented API change to the calls that use it. Review a supported endpoint, parameter, or version fix.

Explore supported sources
Endpoint deprecatedExample
/v1/messages/v2/messages
src/integrations/messages.ts
Review the supported migration
An illustrated repair workbench joining two connectors in a sunlit gardenSmall patch. Clear evidence.

We prepare the fix.
You have the final say.

Since.dev prepares supported repairs. Your team stays in control of what makes it into production.

  • Your checks, already in place.

    Draft PRs use your existing CI.

  • A conversation, on the same PR.

    Request a revision and review the updated patch.

  • The last step is yours.

    Nothing is merged or deployed automatically.

Inspect GitHub CI for the current patch, then use human review to decide whether to merge.

Give your agents
a reality check.

Before an agent acts, check its assumptions against the latest recorded observation.

That’s world state: external facts, versions, and provider conditions, ready for your agents to check.

Explore verification
Does this still hold?example-sdk.version = 19.0.0
Something changed20.0.0

The observation differs. Your agent gets evidence to review.

Illustrative results · check observation time and source health. Verification reads recorded evidence, without a fresh fetch.

Unknown does not mean unchanged.

Shared evidence. Your priorities.

Check it once.
Share what changed.

A public source is checked once for everyone. Each watch gets the changes it cares about.

Your watch instructions and notifications stay private.

How watches work

Less repeated checking. More useful context.

One changing world.
Your way in.

Give your agents the changes they need through MCP, HTTP API, or signed webhooks.

ReadProcessAcknowledge

A durable cursor keeps your place. Reading does not advance it. Acknowledge after processing, then pick up where you left off.

Read the docs

mcp.json

{
  "mcpServers": {
    "since-dev": {
      "type": "http",
      "url": "https://api.since.dev/mcp",
      "headers": {
        "Authorization": "Bearer sc_live_..."
      }
    }
  }
}

Watch subjects, verify facts, inspect coverage, and catch up from the tools your agent already uses.

Integration guide
A little context for every change.
breakingdeprecatedbehavioraladditiveadvisory

Start free.
Build from there.

Your keys. Your choice of where code is processed. Paid plans use your AI provider, billed directly to you.

Free

For developers trying world state and repository impact.

$0 / month

Free, with no card required

Start free
  • 25 hosted AI credits a month
  • 1 connected repository
  • 50 repository dependencies monitored
  • 10 World State watches, every aspect of each
  • Manual impact previews · no repair PRs
  • 100 verification calls a month
  • 1 workspace member

Pro

With repairs

For developers and small teams maintaining their software.

$49 / month

$490 a year, save 17%

Start free
  • Bring your Anthropic or OpenAI key
  • 5 connected repositories
  • No repository dependency count limit
  • 150 World State watches, every aspect of each
  • Automatic repairs and draft PRs
  • 500 verification calls a month
  • 3 workspace members

Studio

For agencies and teams maintaining several applications.

$149 / month

$1,490 a year, save 17%

Start free
  • Bring Anthropic, OpenAI, or AWS Bedrock
  • 15 connected repositories
  • No repository dependency count limit
  • 500 World State watches, every aspect of each
  • Automatic repairs and draft PRs
  • 2,000 verification calls a month
  • 10 workspace members

Enterprise needs? Contact us

Good questions.
Clear answers.

Read the docs
What does self-repairable software mean?
Software that notices an external dependency change and prepares a supported response. Since.dev connects recorded changes to affected code, prepares small evidence-backed patches, and opens draft PRs when authorized. Your repository runs its checks, and you decide whether to adopt the repair.
How often are sources checked?
Sources are checked on a schedule. Each watch uses the slower of its aspect's default cadence and its plan's cadence floor. The watch reports its actual interval. This is scheduled change detection, not a real-time feed.
What does unknown mean?
Unknown means no known value is available for comparison, for example because a subject has no observations or a source does not publish the requested field. Unknown does not mean unchanged. Verification compares the latest recorded observation; inspect its time and source health before relying on it.
What can I watch?
Start with a supported package, repository, specification, public page, or status source. Coverage is checked before a watch is created. Private registries, sources behind a login, and sources closed to automated reading are not covered.
What happens while my agent is offline?
A durable cursor lets your agent resume from acknowledged state and read later changes from its active, attached watches. New watches cover future changes only. Webhooks use at-least-once delivery, so consumers should deduplicate using the event's idempotency key.
What counts toward my plan?
Free includes one repository and a bounded hosted AI allowance. Pro connects five repositories and Studio connects fifteen. Paid repository work requires your own AI provider; there are no repository AI credit quotas or dependency count limits. World State stays on Since AI with separate watch and monthly verification limits. A watched subject counts once across its aspects and attached agents. Each login includes one Free workspace. Additional owned workspaces need their own paid subscription; invited teams do not consume your Free workspace. There are no per-developer charges.
How does bringing my own model work?
On Pro, connect your Anthropic or OpenAI API key and select a supported model. Studio and Enterprise also support AWS Bedrock with an AWS access key ID, secret access key, and region. Your provider bills repository AI usage directly; Since charges for the workspace. Free uses Since AI with 25 hosted credits each month, one repository, and no repair PRs. World State always uses Since AI. Provider usage is visible in settings; it is not a Since invoice. If a connection fails, work pauses instead of switching to another provider.
Do I need to add every repository dependency by hand?
No. Automatic dependency monitoring is checked for new GitHub repository connections; review that choice before connecting. Since scans manifests and monitors supported public dependencies, showing coverage gaps and each source's check status. Existing repository choices are preserved. Repository dependency counts are unlimited on paid plans; Free has a bounded allowance. World State watch limits are separate. Free includes manual impact checks; paid plans can investigate compatibility changes and open supported draft PRs when enabled. Initial readings are baselines, not change notifications.
Does it repair my code automatically?
New paid repository connections default to Automatic draft PRs. Since automatically checks impact, prepares supported repairs, and opens draft PRs; you review and merge. Choose Monitor only to keep repairs manual. Since.dev supports small, documented compatibility fixes in code and configuration. Routine version bumps and work requiring package-manager or lockfile changes are deferred. Insufficient release information means No PR created, with a reason and a background source check when one is scheduled. It does not mean your code is safe or broken. Unsupported work explains the limitation. CI runs in your repository; Since.dev never merges or deploys.
Can I ask for a different fix?
Yes. Revise the repair in the terminal, or explicitly mention the installed GitHub app in a comment on a PR created by Since, with your instruction. Authorized repository collaborators can request bounded changes to the same repair. The app updates the same PR, preserves earlier versions, and waits for fresh checks. It does not take over other PRs or turn unrelated feature requests into automatic work.
Image
A little peace of mind.

Keep building.
We’ll keep watch.

Since.dev watches your dependencies and prepares supported repair PRs. You decide what ships.

Start free