Build with Since.dev.

Grant is the COO for your software operations. He and every specialist on his team are AI agents. Each specialist reads its own sources, saves a brief and says plainly what it could not read. Grant answers your questions in one voice with citations, consults the teammates a question needs and follows your decisions over time. Start in the app with the workspace you intend to use; connections and project scope are configured there.

Set up Grant

1. Sign in and select your workspace. The owner manages billing and invitations; owners and admins configure projects, connections and Grant’s scope.
2. Home walks you through setup until Grant starts: connect a source, choose what the team reads, then start the first check-in. Existing repositories and watches remain connected; there is no need to reconnect them.
3. On Home, choose GitHub or AWS and continue, or connect from Connections → GitHub or Connections → AWS. On GitHub, your first repository becomes your first project. Only following public sources? Create a World State watch without a project.
4. Choose what each project covers on its Access tab: the repositories it covers and what the team may read from AWS.
5. Nothing to set up for AI: Since AI runs on every plan. To use your own provider instead, on a paid plan open Connections → AI provider, turn on Use my own AI provider, type a model ID or pick a suggestion, and choose Test and save connection.
6. Back on Home, review each project and the teammates who can check in on it, then choose Approve and start check-in. The first check-in is the baseline: Home shows Your team is checking in while they work, then what they found.
7. Follow the team on Team. Findings, running assignments and repairs wait in Inbox under Needs you, Assignments, Findings and Repairs. Ask Grant from the composer on Home, company-wide or focused on a project.

Each teammate finishes on its own: a blocked AWS connection does not discard a completed CI brief. The first check-in establishes a baseline; later check-ins mark each finding new, escalated, updated or unchanged against the teammate’s previous brief.

Grant’s team

Grant leads and answers; his specialists do the reading. Each reads only its own sources within the projects in scope and saves one brief per run. A teammate with no eligible source in a project does not check in there. There is no per-seat pricing; you configure project scope, and on paid plans you can choose to use your own AI provider.

Scheduled check-ins follow your plan’s cadence. Liz and Owen check in once a day on Studio and Enterprise; Theo and Vera keep the cadences described below. Event check-ins start when GitHub reports a workflow run, a check or a push on the default branch, or a new Dependabot or code scanning alert, or when a repository impact updates. Iris works on request only: ask Grant about watches or what changed and Iris answers from World State. She creates, changes, pauses or attaches watches and runs fact checks only when you ask; the request is the consent. Fact checks use your plan’s verification allowance.

Harper works when you ask Grant for a document; her one scheduled job is the Monday ops brief, sent as the weekly digest when it is on. She reads her teammates’ saved briefs and any attached or company document the request names, uses only the numbers and findings they give, names the teammate or document each one comes from and states a missing or old brief as a gap. Pro includes company operations reports and the Monday ops brief; Studio and Enterprise add one-pagers for a named reader and board decks. Every report is saved on Reports and downloads as Markdown or PDF, and a deck also as PowerPoint. Owners and admins can share a read-only link that expires after 7 days. Harper is on Pro and up; Free shows her as Available on Pro.

Theo keeps one setup plan: what your cloud account and repositories have not set up yet, or have set up below a sensible standard, most important first. Each item says why it matters, what it costs (including what AWS bills for it), how to do it, how Theo checks it is done and the standard it comes from, such as the CIS AWS Foundations Benchmark or AWS Well-Architected, as guidance and never as a compliance claim. He checks in with your first baseline, then monthly on Pro with the top five items, and weekly on Studio and Enterprise with every item and its snippets. An item leaves the plan when a later check-in no longer sees it. Ask Grant for the setup plan to save it on Reports, or ask why a teammate cannot see something, such as Liz and your costs. Theo never changes anything. He is on Pro and up; Free shows him as Available on Pro.

On Pro and up, Liz explains last month’s AWS bill each month: what moved by service and usage type, with the deploys and merged pull requests around each jump as leads. Studio and Enterprise add who made each change, from the last 14 days of CloudTrail event history, and the hidden costs, each with its usual fix.

On Studio and Enterprise, ask for the vendor register: Iris lists every vendor the code, AWS bill and workflows show you use, what is on file for each, and drafts of the subprocessor list update and customer notice for you to send. She searches the company documents on Context for SOC 2 reports, DPAs and your own vendor list. Since keeps no answers between registers: to add a vendor the code does not show, or answer a question, upload or update your vendor list, SOC 2 report or DPA there, and the next register reads it. Until then the question stays on the list.

Vera tests your own agents the way an attacker would, weekly: goal hijack and prompt injection, system prompt and data disclosure, tool misuse, memory poisoning and rogue behaviour, mapped to the OWASP Top 10 for Agentic Applications. She tests only endpoints you confirm you own in Connections → Agent endpoints, within the monthly budget and rate limit you set, and runs a destructive case only on an endpoint marked a sandbox. Each run saves a finding for each category that failed, with a transcript excerpt and the fix, and the agent security report on Reports with a score per category and what regressed. Vera is on Studio and Enterprise only; Free and Pro show her as Available on Studio.

Projects and responsibilities

A project groups the operational context for a product, service or initiative. It can contain several repositories, selected paths in a shared monorepo, only cloud resources, or a combination. Analysis paths and resource bindings define Grant’s scope. They do not expand repository repair consent or access granted to an external coding agent.

Missing permissions, disabled scanners, missing metrics and partial reads appear as coverage gaps. A completed check-in can have incomplete evidence. Shared AWS costs stay account-level context unless AWS attributes them; Grant does not invent a project’s share. Company-wide questions can compare projects.

Pausing a project keeps its capacity slot. Archiving it releases the slot and stops the team’s work on it while retaining records. Repository watch and repair settings remain separately managed. Existing repository history, identifiers, monitoring choices and benefits are preserved.

GitHub and AWS connections

Open Connections → GitHub and choose Connect repository to install or authorize the GitHub App and select a repository, then add it to an existing project or choose Create a new project. CI and security need the corresponding GitHub App read permissions and available data; signing in with GitHub alone does not connect a repository.

Open Connections → AWS, name the connection, enter the AWS account ID and the regions you approve, and choose Prepare AWS connection. Create read role in AWS opens a CloudFormation template in your account that creates a read-only role named GrantReadOnly-<connection id>, trusting Since’s principal with the connection’s generated external ID. Where guided creation is unavailable, the page shows the role ARN, external ID and trusted principal for manual setup. After AWS confirms the role, choose Verify access.

The current template attaches AWS’s ViewOnlyAccess for runtime and SecurityAudit for security, keeps a short list of billing reads for costs, and explicitly denies reading data, files, logs, secrets, environment variables and code. Grant sees what you run and what it costs. It never reads your data, files, logs or secrets. AWS’s managed read policies can’t be limited by region, so Grant reads only the regions you approve in its own code. Approve us-east-1 so Grant can see changes to IAM, such as new access keys and administrator access. AWS records them only in that region.

An account set up with an older template keeps working, and a read it does not allow shows as a coverage gap. To update it, an owner or admin chooses Update AWS permissions on Connections → AWS. In CloudFormation, keep the template URL and every parameter as shown, acknowledge that the stack changes IAM resources, and submit. The role, its ARN and external ID stay the same, so nothing needs to be verified again.

AWS credits

AWS does not report a credit balance. On Pro and up, owners and admins enter the balance, the day it was true and when the credits expire under AWS credits on Connections → AWS. Liz works out how long the credits last from it and from the credits applied each month in Cost Explorer, read back to the balance’s date for up to 12 months. A balance older than that, or credits past their expiry date, needs a current balance before Liz can give a runway. Credits applied at a management (payer) account may not show in a member account.

GitHub events

The GitHub App also receives deployment status, repository, branch protection rule, member and organization events. Deployment status and branch protection events need the Deployments and Administration read permissions: approve the App’s permission request on your installation if GitHub shows one. On Studio and Enterprise, about an hour after each successful production deployment of a project that selects AWS resources, Noah compares errors, throttles, duration and database load with the hour before. He may recommend a rollback but never does one. A repository made public, branch protection removed, an outside collaborator or organization owner added, or a force push to the default branch posts Priya’s risky change notice within minutes. Organization events need the App installed on the organization. Grant keeps identifiers, states and logins from each event, never commit messages or contents, for seven days.

On the project’s Access tab, choose Choose access (or Edit access) on a validated AWS account to pick what the team may read: Costs, Health of watched resources, and Security findings set to None, Watched resources only or Whole account. Resource-only security reads only the resources you paste under Watched resources. Health reads those resources’ metrics and, on paid plans, the account’s inventory in the approved regions (on Studio and Enterprise, also its CloudTrail changes). Then choose Save access. When a teammate needs setup, its link opens a guided dialog for that need, such as Choose what Noah watches. Selecting an AWS connection alone does not give every project the whole account.

Cost Optimization Hub must already be enrolled and populated; Security Hub and repository scanners must already provide findings. Grant never enables these services or changes cloud permissions for you. AWS reads can incur provider charges. Operational AWS access is separate from a Bedrock model connection.

Plans, credits and AI providers

Each plan also includes these of Grant’s capabilities, with the teammate who does each. A teammate who owns a capability joins only on plans that include it.

Paid plans add scheduled and event check-ins and live consults, bounded by per-run execution and request limits. They count projects rather than imposing a separate repository cap, and have no repair-count quota. Free’s eligible draft repair PR allowance is separate from Grant’s monthly baseline and follow-up check-ins, which use Since AI credits like all other Since AI work. The eligible draft repair PR still runs when Free credits are used up; its AI work counts toward them. A retried request does not use another allowance.

Using your own AI provider is optional on Pro, Studio and Enterprise. An owner or admin turns on Use my own AI provider in Connections → AI provider. To use your own AI provider, connect Anthropic or OpenAI on Pro. Studio and Enterprise also support AWS Bedrock and any OpenAI-compatible endpoint, such as OpenRouter or Moonshot, by its HTTPS base URL. Choose the provider, type any model ID your account can use or pick a suggestion, enter the credentials and choose Test and save connection. The test checks a strict structured reply and one streamed strict tool call. Grant also needs a model with strict structured output, such as Claude Sonnet 4.6 on Bedrock, or Anthropic or OpenAI directly; the connection shows whether a model is ready for Grant. A model that passes but is not ready for Grant still serves repairs. A failure names its category: invalid key, no access, model not found, rejected settings, unsupported, rate-limited or unreachable. One provider and model serves Grant, his team and repository AI. When you use your own provider, it bills model usage directly and no credits are used. An unavailable model blocks new work without switching to Since AI.

Every plan runs on Since AI by default, measured in credits: 1,000 a month on Free, 25,000 on Pro and 80,000 on Studio, and the contract amount on Enterprise. Credits reset on the 1st (UTC) and do not roll over. Free and Enterprise stop using Since AI at their allowance until the 1st. Pro and Studio keep going: credits past the allowance are billed automatically as extra credits at $2.00 per 1,000 on Pro and $1.50 per 1,000 on Studio, on a separate Extra credits invoice after the month closes. There is no cap and nothing to switch on. If a subscription payment is past due, or an Extra credits invoice is unpaid 7 days after it was issued, Pro and Studio stop at the allowance until the payment goes through; after an Extra credits invoice is paid, Since AI resumes within a day. Each month is priced at the higher of Pro and Studio the workspace was on during it, with Studio above Pro: moving from Studio to Pro or to Free, or from Pro to Studio, during a month prices the whole month at Studio. After a move from Studio to Pro, Usage and billing shows Studio’s included credits and rate until the month ends. If you cancel, or move to Free, during a month, the extra credits you used are still billed after the month closes, on the card from your last subscription. Deleting a workspace that was on Pro or Studio this month, or the account that owns it, first charges its extra credits so far, and any unpaid Extra credits invoice, to the card on file. Usage and billing shows credits left, the reset date and this month’s extra credits; a banner appears at 80% and 100% of the allowance, and the owner gets an email when the allowance runs out and each time extra credits pass a multiple of the plan price.

The plan sets the check-in cadence. Check-ins are separate from existing World State polling. Plan changes preserve saved records and any protected legacy benefits. Capacity blockers identify what needs attention; they do not delete history or clear manual pauses.

Stop, pause and limits

Choose the projects and sources Grant may work on. No specialist configuration is required. Every plan has Since AI credits, and every plan keeps bounded limits on each run, such as source reads and tokens per teammate run. These limits are ceilings, not dollar spending caps, and extra credits on Pro and Studio have no cap. Keep credentials out of questions and evidence.

While Grant answers, Stop in the composer ends the turn. The asker, or an owner or admin, can stop each consulted teammate on its own; saved results are kept. A running assignment in Inbox has its own Stop.

Owners and admins can pause Grant and the whole team (Team → Pause Grant), one teammate (Pause coverage on the teammate’s page), a project (Pause on its page), an AWS connection (Pause reviews in Connections → AWS) or a delivery destination (Pause delivery in Connections → Slack & webhooks). A pause stops matching runs and deliveries. Releasing a pause lifts only that pause, so a narrower pause survives a company-wide resume. Saved evidence stays readable, and resuming rechecks current authorization and limits. A delivery whose outcome is unknown is never resent automatically, because the destination may already have it.

Consults and decisions

Ask Grant from the composer on Home, company-wide or focused on a project, or with Ask Grant on a repository or a repair. Answers draw on saved findings, evidence and decisions. On a paid plan, when fresh work is needed, Grant consults up to six teammates at once, for read-only work except Vera’s tests of your own agents. Each appears as a lane under Consulting with its progress, and each can be stopped on its own. Work still running after about 45 seconds, or when you ask, continues in the background and reports back once, as a Follow-up in the same conversation. Ask “how’s Owen doing?” for a teammate’s live status. Citations come only from what Grant’s tools and teammates returned. Free answers from saved results only, says as of when and shows no lanes. Continue the same conversation to retain that context.

Findings separate observation, interpretation, recommendation and uncertainty. Open one from Inbox → Findings to inspect its evidence and record a disposition (Accepted, Deferred, Addressed or Dismissed), an Owner, a Decision note or a Revisit on date with Save decision. Deferring keeps the decision and its date visible. Marking a finding addressed records your decision; it is not proof that the underlying issue is resolved. Absence from a later brief is not proof either.

Later check-ins compare against each teammate’s previous brief and bring owners, deferrals and revisit dates forward. A teammate that cannot read a source reports the gap beside what the rest of the team found.

Slack and notifications

An owner or admin installs Slack from Connections → Slack & webhooks and invites @Grant to the channels where he should answer. A new connection covers All projects, including new ones; an owner can narrow it to chosen projects. A channel for team notices is optional: without one, notices and the weekly digest go to the managing member’s DM with Grant. The installer is linked at install. Other members are linked on first contact when their Slack email is the verified email of exactly one member of the Since workspace; otherwise they get a link to connect their Slack identity.

Ask with /grant and a question, or mention @Grant in a channel. Grant answers publicly in that channel’s thread (for /grant he posts the thread’s root first), attributed to the asker and discussing only the connection’s projects. Follow-ups in the same thread continue your stored conversation; another member asking in that thread gets their own. /grant with no question shows how to ask, privately. Start with /project "Exact project name" to focus a question on one project. In a channel Grant has not joined, /grant still answers through Slack’s response URL and suggests inviting @Grant to see live progress in a thread.

DM Grant for a private, persistent conversation over your own access; each DM answer ends with a “Continue with Grant in Since” link. One status message per question shows the team working, with teammates’ names and fixed phase words, edited in place at most every three seconds; then the answer is posted as plain text. Nothing Grant says in Slack is ephemeral; the only private text is the slash command’s acknowledgement. Grant reads only messages addressed to him, never channel history.

A check-in’s notice carries its title and its urgent findings’ titles and severities, never evidence. Create webhook destinations with selected projects in the same settings; save their generated signing secret when it is shown. These are separate from World State agent webhooks.

On Pro and up, Add destination also adds an email destination: choose its projects and the workspace members it goes to, at most 20. It sends what Slack would show, with a button to Since. Grant emails a member only while their email is verified and Email me Grant’s notices is on in Settings → Notifications. Free has no email.

A check-in posts a team notice only for a new or escalated critical or high finding, or for a source it newly could not fully read. On Pro and up the optional weekly digest is Harper’s Monday ops brief, written from Monday 08:00 UTC over each destination’s projects; otherwise it links to the team’s latest check-in. Delivery retries reuse saved results and never rerun a check-in. Revoke a destination, or choose Pause delivery, from Connections → Slack & webhooks.

Alarms and risky changes

On Studio and Enterprise, Grant checks each AWS account given a project every five minutes. When CloudWatch alarms go into ALARM where Noah watches resources, he posts one first look that names them all. A risky change posts Priya’s notice within minutes: a root user sign-in, CloudTrail logging stopped, GuardDuty turned off, a new access key, administrator access given, a security group opened to the internet, a change to an S3 bucket’s access settings, or one of the GitHub changes above. These notices carry their evidence into Slack, email and webhooks: for an alarm, the alarm, where and since when, and the changes and deploys just before; for a risky change, who changed what, when and where, why it matters and the usual fix. Each ends with “Likely cause, not verified.” Treat it as a lead to check. Noah’s notice also lists the urgent findings his first look filed, by title and severity. After a risky change, Priya checks what it left exposed and posts the urgent issues she finds in a notice of its own. Changes to IAM need us-east-1 approved.

Reminders and follow-ups

On Pro and up, making someone else a finding’s owner tells them, with a link to the finding and its decision controls, and a finding whose revisit date arrives tells its owner once. An accepted risk comes back for review the same way. Inbox → Findings has an Assigned to me filter. On Studio and Enterprise, each action item of a saved postmortem becomes an open follow-up. While it stays open past its revisit date, its owner hears about it once a week, and when a teammate’s evidence shows the proof it names, such as a merged pull request or a fixed alert, Grant says so. Only a person marks it addressed. A member’s own notices go to their Slack DM with Grant, else their email on Pro and up, else Inbox → Updates.

Alerts

On Pro and up, ask Grant to watch a number for you, such as “Flag me if AWS goes over $3k this month”, or choose Alert me on the cost tile on Home or on a budget, cost, certificate, alarm or security finding. When you ask, Grant suggests the alert and you save it; one asked for in Slack waits 24 hours on the Alerts page under Waiting for you to save. The teammate who reads that evidence checks it each time they finish a run, and you hear once when it crosses, as a member’s own notice. You can send an alert to one of the workspace’s destinations instead (a Slack channel, a signed webhook or an email destination): it then posts there with what crossed, while that destination is given every project it fired for, and otherwise comes to you with the reason. It fires again only after a run reads it back below the line. A new critical security alert or an alarm going into ALARM fires once for each new one. Pro keeps 20 alerts per workspace; Studio and Enterprise are fair use. Alerts do not replace your own monitoring.

Create an organization, mint a key from the dashboard, and make the two calls that matter: watch the public sources you depend on, then read what changed. Everything else is refinement.

curl -X POST https://api.since.dev/v1/subscriptions \
  -H "Authorization: Bearer $SINCE_DEV_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "items": [
      { "subjectType": "package", "subject": "npm:react", "aspect": "versions" },
      { "subjectType": "package", "subject": "npm:react", "aspect": "deprecation" },
      { "subjectType": "project", "subject": "vercel/next.js", "aspect": "releases" }
    ]
  }'

Over MCP the same step is one call: subscribe({ subjectType: "package", subject: "npm:react", aspect: "versions" }). You can also paste a dependency manifest in the dashboard and activate the packages you care about.

You can create your first watch before connecting an agent, or skip setup and explore the terminal. A first check records the baseline. Later changes appear when detected; an empty feed means there is nothing to report yet.

curl "https://api.since.dev/v1/changes" \
  -H "Authorization: Bearer $SINCE_DEV_KEY"

# {
#   "changes": [ { "change": { ... }, "context": { ... } } ],
#   "cursor": 84219,
#   "hasMore": false,
#   "truncated": false,
#   "acknowledgeable": true,
#   "delivery": "at-least-once; acknowledge only after processing, and dedupe on idempotencyKey",
#   "filtering": "no relevance filter; returns every change available to an active watch. A paused or closed watch stops contributing changes, including changes returned earlier"
# }

Every request carries an API key as a bearer token. Keys look like sc_live_<prefix>_<secret> (a 12-character lookup prefix and a 192-bit secret, both hex) and are shown once at creation. Only a SHA-256 digest is stored, so a lost key is replaced rather than recovered.

Authorization: Bearer sc_live_9f2c4b8e1a03_7d1e...

A key belongs to one agent inside one organization, and every response is scoped to that organization. There are no sandbox or test keys; use a free account when you want to evaluate the API without starting a paid plan.

Classification

An assessed change carries one of five categories as verdict.category, beside verdict.severity.

Changes may arrive without classification, with verdict: null and judge.judged: false. Use the change details and source evidence to assess them. A missing verdict does not mean the change is harmless or cosmetic.

Connect a GitHub repository to monitor its dependencies, check impact when an upstream change lands, and review supported repairs as draft PRs.

1. ConnectPick a GitHub repository.
2. MonitorIts dependencies and their sources.
3. RepairSupported repairs open as draft PRs.
4. ReviewGitHub checks; people decide.

Connect a repository

Open Connections → GitHub and choose Connect repository. Connect GitHub if needed, select an accessible repository, and review the monitoring and repair choices. Automatically monitor dependencies is checked for new connections. Paid connections default to Automatic draft PRs; Free uses Monitor only with manual impact checks and on-demand eligible repairs. Existing repository choices are preserved.

Monitoring and repair modes

The mode follows the plan; the repository’s Allowance panel shows which one applies.

Owners and admins manage repository setup and repair permissions. Draft PRs require GitHub Contents and Pull requests write access. This permission does not turn routine dependency releases into upgrade PRs. Work requiring package-manager execution, lockfile generation or workflow changes is deferred without publishing an incomplete fix.

Where GitHub doesn’t offer draft PRs (private repositories on GitHub Free or Pro), the repair opens as a regular PR titled [Needs review]. Since.dev never merges it.

Changes, dependencies and sources

A repository opens on Changes, with Repair PRs, Dependencies and, for owners and admins, Settings alongside it. Review affected changes, repairs, and monitored dependencies from these tabs. To monitor only part of a monorepo, list its paths in Settings → Repository directories. Rescan dependencies updates the dependency list; each external source is checked on its own schedule. Paused or excluded dependencies remain visible so you can resume monitoring later.

Free repository dependencies have a separate allowance from World State watches, counting once across connected repositories in the workspace. Paid plans have no repository dependency count limit. To add a source outside a manifest, use the repository’s Watches panel.

The first source reading is a baseline, not a repair trigger.

Plans and AI providers

Free includes 1,000 Since AI credits a month, one connected repository, and one eligible draft repair PR per UTC calendar month on demand. Since AI does the repository analysis and repairs on every plan and uses credits. Grant Pro includes five active projects and Studio fifteen. On a paid plan you can use your own AI provider instead: Anthropic or OpenAI on Pro; Studio and Enterprise also support AWS Bedrock and OpenAI-compatible endpoints. A project can contain multiple connected repositories; paid plans do not impose a separate repository count limit.

To use your own provider, a workspace owner or admin opens Connections → AI provider, turns on Use my own AI provider, enters credentials, types a model ID or picks a suggestion, chooses Test and save connection, and reviews usage. Your provider then bills repository analysis and repairs directly and they use no credits. World State remains on Since AI with separate monthly limits. With the switch on, a missing or invalid connection pauses repository AI work until you reconnect it; it never moves to Since AI by itself.

Review a repair

Open a repair to see what changed and what needs review first, with Captured source evidence, Sources and Code evidence for the source material and code findings. Insufficient evidence means No PR created, with no charge and a plain reason; it does not mean the code is safe or broken. Background source check appears only when a future recheck is scheduled. Access refusals are respected. Unchanged evidence, code and instructions reuse the prior decision instead of repeating paid analysis.

On Free, use Check a change for a manual impact check; it uses Since AI credits. Choose Prepare repair on eligible symbol renames or endpoint replacements. The allowance is consumed only when a draft PR opens; failed attempts do not count. Three generation attempts are available each UTC calendar month, with two requested revisions of the same PR within 30 days. Current workspace management permission and GitHub write access are required. Free never opens PRs automatically.

In Automatic draft PRs mode, Since automatically checks the impact of recorded changes, prepares supported repairs, and opens draft PRs. The optional Check a change control checks one recorded change by hand; it is not a required workflow step.

Ask for a revision

For a different fix, choose Revise this PR, give a concrete instruction, and select Send revision. Or add a new PR/review comment on a PR created by Since, with the installed GitHub app’s exact mention followed by a space and your instruction, such as @your-app-slug keep the public method name unchanged. The app verifies the commenter's live write permission and limits the change to the same repair and evidence. It updates the same PR with a new patch version and fresh checks. Ordinary comments do not trigger paid work. PRs that Since did not create, and closed or merged PRs, are not edited.

Workspaces, members and billing

• Use the account menu to create or switch workspaces, including invited teams.
• Settings → Members contains invitations and roles.
• Authorized managers can copy a pending invitation link if the email does not arrive.
• Recipients must sign in with the invited email; an accepted link can reopen the team while membership remains.
• Each login includes one Free owned workspace.
• Every additional owned workspace requires its own paid subscription.
• Creating a workspace opens billing for that workspace; payment is required before monitoring or repository work starts.
• Checkout updates the currently selected workspace.
• Pro and Studio bill extra credits after each UTC month closes, on a separate invoice charged to the card on the subscription. A month is priced at the higher of Pro and Studio the workspace was on during it, with Studio above Pro. If you cancel, or move to Free, during a month, the extra credits used are still billed after the month closes, on the card from your last subscription.
• On a paid plan, owners and admins can switch the workspace to their own AI provider.
• Owners manage billing and roles; admins can invite/remove members; members cannot administer repositories or open repair PRs.
• Ownership transfer is unavailable.
• Deleting an additional workspace cancels its subscription and removes its data while preserving your login and other workspaces. If it was on Pro or Studio this month, its extra credits so far are charged first.

Reject an irrelevant repair or disconnect a repository to stop new work. Rejected work is not silently recreated. Disconnection releases the Free repository slot while retaining repair history; existing GitHub PRs remain under your control. Archive a project from its project page to release Grant project capacity.

Let your coding agent inspect repairs

Share repository access with agents in the repository’s Settings → Agent access. This is an explicit grant: watching a dependency alone does not grant code or repair access. These bearer-authenticated reads expose only shared repositories.

All requests and responses are JSON. Times are ISO 8601 in UTC. Unknown fields in a request body are ignored rather than rejected, so a typo in an optional field name is silently the default. Check the echoed values in the response if a setting does not seem to have taken.

Watches

{
  "set": { "id": "set_9c14b027", "name": "Direct subscriptions" },
  "created": 2,
  "alreadySubscribed": 0,
  "blocked": [],
  "watching": [
    { "id": "sub_react", "subjectRef": "npm:react", "aspect": "versions" },
    { "id": "sub_linear", "subjectRef": "Watch Linear's changelog", "aspect": null }
  ],
  "removed": 0,
  "closed": 0,
  "planned": [
    { "id": "sub_linear", "statement": "Watch Linear's changelog", "created": true }
  ],
  "statementResults": [
    {
      "ok": true,
      "itemIndex": 1,
      "childIndex": 0,
      "statement": "Watch Linear's changelog",
      "id": "sub_linear",
      "created": true
    },
    {
      "ok": false,
      "itemIndex": 1,
      "childIndex": 1,
      "statement": "Watch Stripe's changelog",
      "error": {
        "code": "needs_clarification",
        "message": "Which Stripe changelog should be watched?"
      }
    }
  ]
}

Sets

A set is a named group of watches: a repository’s dependencies, a starter pack, a team’s list. Attachment to a set is what makes its watches visible to your key, whoever created them. Anything you create through POST /v1/subscriptions lands in your own set automatically. Attach to any other set whose watches this agent needs to receive.

Verify

{
  "checked": 2,
  "results": [
    {
      "subjectKey": "package:npm:left-pad",
      "aspect": "deprecation",
      "fieldPath": "deprecated",
      "verdict": "changed",
      "expectedValue": null,
      "currentValue": "use String.prototype.padStart",
      "reason": null,
      "observedAt": "2026-08-04T09:12:44Z",
      "source": "npm, Inc."
    },
    {
      "subjectKey": "package:npm:not-watched",
      "aspect": "versions",
      "fieldPath": "version",
      "verdict": "unknown",
      "expectedValue": "1.0.0",
      "currentValue": null,
      "reason": "Since.dev has never observed this subject.",
      "observedAt": null,
      "source": null
    }
  ]
}

Changes

{
  "cursor": 84219,
  "hasMore": false,
  "truncated": false,
  "acknowledgeable": true,
  "delivery": "at-least-once; acknowledge only after processing, and dedupe on idempotencyKey",
  "filtering": "no relevance filter; returns every change available to an active watch. A paused or closed watch stops contributing changes, including changes returned earlier",
  "changes": [{
    "change": {
      "seq": 84219,
      "changeId": "chg_5b21...",
      "idempotencyKey": "a3f1c9...",
      "subject": {
        "key": "package:npm:left-pad",
        "type": "package",
        "name": "left-pad"
      },
      "aspect": "deprecation",
      "kind": "state_change",
      "fieldChanges": [{
        "path": "deprecated",
        "label": "deprecated",
        "from": null,
        "to": "use String.prototype.padStart"
      }],
      "headline": "left-pad was deprecated",
      "source": {
        "publisher": "npm, Inc.",
        "url": "https://registry.npmjs.org/left-pad/latest"
      },
      "significance": 0.94,
      "detectedAt": "2026-08-04T09:12:44Z",
      "occurredAt": null,
      "subscriptionIds": ["sub_2f9a7c31"]
    },
    "context": {
      "judge": {
        "judged": true,
        "source": "model",
        "fallback": false,
        "model": null,
        "judgedAt": "2026-08-04T09:12:45Z"
      },
      "verdict": {
        "severity": 0.72,
        "category": "deprecated",
        "basis": ["The package is deprecated in favour of a language built-in."],
        "breaking": { "answer": "no", "reasoning": "The published code still installs and runs." },
        "upstreamGuide": {
          "available": true,
          "text": "use String.prototype.padStart",
          "why": "The publisher named the replacement rather than restating the field."
        }
      },
      "subjectType": "package",
      "publisher": "npm, Inc.",
      "changedFields": ["deprecated"],
      "evidenceQuote": "use String.prototype.padStart",
      "summary": "The publisher deprecated left-pad in favour of a language built-in."
    }
  }]
}

Coverage

{
  "coverage": "good",
  "explanation": "npm publishes version and deprecation metadata directly.",
  "suggestion": null,
  "sources": [{
    "publisher": "npm, Inc.",
    "rationale": "Authoritative registry for this package."
  }],
  "cadenceMinutes": 720,
  "subject": { "key": "package:npm:react", "name": "react", "qualifier": null },
  "candidates": [ ... ]
}

Subjects

{
  "subject": { "key": "package:npm:react", "name": "react", "type": "package" },
  "changes": [ ... ],
  "volatility": {
    "total": 34,
    "firstSeen": "2026-01-18T04:00:11Z",
    "lastChangeAt": "2026-07-29T17:41:02Z"
  }
}

Webhook endpoints

Usage

{
  "plan": "pro",
  "limits": {
    "subscriptionsLimit": 150,
    "verificationsPerMonth": 500,
    "membersLimit": 3
  },
  "usage": {
    "activeSubscriptions": 11,
    "verificationsThisMonth": 402
  },
  "credits": {
    "included": 25000,
    "used": 18420,
    "available": 6580,
    "resetsAt": "2026-11-01T00:00:00.000Z",
    "overage": {
      "credits": 0,
      "cents": 0,
      "ratePer1000Cents": 200
    },
    "canSpend": true,
    "blockedReason": null,
    "payer": "since"
  },
  "hostedAllowance": null
}

Every delivery is a POST with a JSON envelope and four primary headers. World-State-Signature carries a unix timestamp and an HMAC-SHA256 over `${t}.${rawBody}`, computed with your endpoint’s signing secret.

POST /your/endpoint HTTP/1.1
Content-Type: application/json
World-State-Signature: t=1785312764,v1=9f2c4b8e...
World-State-Event: change.detected
World-State-Delivery: whd_51c0...
Idempotency-Key: sub_2f9a7c31:a3f1c9...

{
  "id": "whd_51c0...",
  "type": "change.detected",
  "idempotencyKey": "sub_2f9a7c31:a3f1c9...",
  "createdAt": "2026-08-04T09:12:46Z",
  "data": {
    "subscriptionId": "sub_2f9a7c31",
    "change": {
      "seq": 84219,
      "changeId": "chg_5b21...",
      "idempotencyKey": "a3f1c9...",
      "subject": { "key": "package:npm:left-pad", "type": "package", "name": "left-pad" },
      "aspect": "deprecation",
      "kind": "state_change",
      "fieldChanges": [{ "path": "deprecated", "label": "deprecated", "from": null, "to": "..." }],
      "headline": "left-pad was deprecated",
      "source": { "publisher": "npm, Inc.", "url": "..." },
      "significance": 0.94,
      "detectedAt": "2026-08-04T09:12:44Z",
      "occurredAt": null,
      "subscriptionIds": ["sub_2f9a7c31"]
    },
    "context": { "judge": { "...": "as in GET /v1/changes" }, "verdict": { "...": "the same saved verdict" }, "subjectType": "package", "publisher": "npm, Inc.", "changedFields": ["deprecated"], "evidenceQuote": "use String.prototype.padStart", "summary": "The publisher deprecated left-pad." }
  }
}

import { createHmac, timingSafeEqual } from "node:crypto"

function verify(rawBody, header, secret, toleranceSeconds = 300) {
  const parts = Object.fromEntries(
    header.split(",").map((piece) => piece.split("=").map((s) => s.trim())),
  )
  const timestamp = Number(parts.t)
  if (!Number.isFinite(timestamp)) return false

  // Reject replays of a captured body.
  const age = Math.abs(Math.floor(Date.now() / 1000) - timestamp)
  if (age > toleranceSeconds) return false

  const expected = createHmac("sha256", secret)
    .update(timestamp + "." + rawBody, "utf8")
    .digest("hex")

  const a = Buffer.from(expected, "hex")
  const b = Buffer.from(parts.v1 ?? "", "hex")
  return a.length === b.length && timingSafeEqual(a, b)
}

Event types

One type, and that is the whole list. Coverage loss is not pushed today: check status on GET /v1/subscriptions for that.

Retries

Any non-2xx response or a timeout past 15 seconds is retried with exponential backoff (30s, 60s, 2m, 4m, doubling to a one-hour cap) for up to 8 attempts. If every attempt fails, the delivery is retained and surfaced in the dashboard. Five consecutive failures mark the endpoint degraded. Nothing is dropped silently.

Return 2xx as soon as you have durably accepted the event, and do the work afterwards. Deliveries are at-least-once, so deduplicate on idempotencyKey. The same change reaching two of your endpoints carries the same key.

Webhook deliveries and retries are never billed. The same change also remains available from /v1/changes, so a webhook is one delivery mode rather than the only way to recover it.

Grant, World State and repository tools are available over Streamable HTTP at https://api.since.dev/mcp. Authenticate with the same bearer key, or skip the key entirely: clients that support remote MCP sign-in (Claude, Codex, Cursor) can add https://api.since.dev/mcp as a remote server and sign in through the browser when prompted. The credential determines which workspace the connection can access.

Grant is the same COO, with the same team, findings and workspace execution limits, in the app, Slack and MCP. A key or browser sign-in does not give an agent private Grant access automatically. An owner or admin opens Connections → External agents, chooses Manage on the connection and, under Grant access, chooses the Projects shared with this connection and its Allowed actions. Existing watch and repository grants remain separate.

Browser sign-in asks a current owner or admin to choose the workspace, the projects (named ones, or all current projects as a snapshot that leaves out future ones) and the permissions. Approving no projects is allowed. Changing a connection’s approved scope, revoked access or a lost membership requires reconnecting. API keys and browser sign-ins issued before this approval step keep working without reconnecting. Switching workspaces in the terminal does not retarget an existing agent key or browser MCP session.

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

The server lists 21 tools: 6 Grant tools and 15 platform tools for World State, repositories and usage. Start with grant_team_status to see your approved projects, your permissions and Grant’s team. With no project approved, every tool is listed, grant_team_status returns Grant’s team with links to where access is set up, and the other Grant tools return grant_access_denied. With projects approved, the connection lists the platform tools and the Grant tools its permissions allow: read alone adds grant_team_status and grant_read. Changes to a project’s scope require renewed access. A removed member, revoked key or expired browser session cannot continue Grant’s work using an earlier grant.

Additional shared reads include inspect_repository for repository status, list_watches for a paginated watch inventory, and inspect_watch for saved coverage and source health. These respect existing repository and watch grants without requiring a Grant project setup.

Grant tools and authority

Each Grant call takes a typed input object and, optionally, applicationIds to narrow it; without them it covers every project approved for the connection. A question also takes a stable requestKey; if Grant is still working when the wait ends, call again with the same question and key to keep waiting instead of asking again. Saved reads do not call a model.

{
  "conversationId": "conv_7c1e",
  "runId": "run_52aa",
  "status": "running",
  "answer": null,
  "team": [
    {
      "employee": "liz",
      "name": "Liz",
      "runId": "run_52ab",
      "status": "running",
      "background": false,
      "activity": "AWS costs",
      "summary": null
    }
  ]
}

Once the turn completes, answer holds messageId, content and references, the records Grant’s tools and teammates returned.

Permissions are separate: read, question, investigate, decision and control. A question that has Grant consult his team also needs investigate. Grant’s tool schemas describe current arguments and version requirements. No Grant tool grants cloud writes, CI reruns, merges or deployments.

World State and repository tools

To resume World State monitoring, call what_changed_since first. Call verify_facts before acting on remembered facts.

subscribe takes exactly one of two forms: typed or statement. Typed subscribe registers exactly one watch from subjectType, aspect, and exactly one of subject or canonicalKey (pass canonicalKey when answering an ambiguous_subject error or when you already hold a key from check_coverage), then returns that watch directly. The statement form may produce one or more ordinary watches, up to ten per call. One watch keeps the same direct response shape. Several watches return an ordered results array with a success or error for each watch. Successful watches remain active when another result fails.

{
  "results": [
    {
      "ok": true,
      "childIndex": 0,
      "statement": "Watch React releases",
      "watch": {
        "id": "sub_react",
        "subject": {
          "displayName": "React",
          "type": "package",
          "typeLabel": "Package",
          "qualifier": "npm",
          "jurisdiction": null,
          "identifiers": { "registry": "npm", "name": "react" }
        },
        "aspect": "versions",
        "setId": "set_9c14b027",
        "status": "active",
        "coverage": "good",
        "coverageExplanation": "Covered by the official release feed.",
        "threshold": null,
        "cadenceMinutes": 360
      }
    },
    {
      "ok": false,
      "childIndex": 1,
      "statement": "Watch Stripe's changelog",
      "error": {
        "code": "needs_clarification",
        "message": "Which Stripe changelog should be watched?"
      }
    }
  ]
}

POST https://api.since.dev/mcp
Authorization: Bearer sc_live_...

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "what_changed_since",
    "arguments": { "limit": 50 }
  }
}

Supported methods: initialize, notifications/initialized, tools/list, tools/call, and ping. Protocol version 2025-06-18. A GET on /mcp returns a discovery document.

The agent API takes typed inputs: subjectType names what kind of thing you mean, and aspect names what about it you care about. These lists define the input vocabulary, not a promise that every combination is covered. The coverage response names the available sources and cadence, or none with the reason.

Subject types

Aspects

Errors return { "error": "<code>", "message": "<human text>" }, sometimes with details or issues.

Limits