# Which services are on the Provely roadmap?

> The services that Provely plans to verify next, listed by category. No signed skill and no completion contract exists for one of them yet.

Canonical: https://provely.sh/verify/roadmap  
Last reviewed: 2026-09-05  

**The roadmap names 100 services. A roadmap entry is not a skill. No contract, no certification and no verdict exists for it. Provely verifies nothing in that service today.**

## What does a roadmap entry state?

- The service and the category state where the work sits in the priority list.
- The "What an agent does there" sentence states the side-effecting action.
- The "What the acknowledgement does not prove" sentence states the completion gap.
- Both sentences come from provider documents. Each dossier cites every document with a retrieval date.
- A dossier also records the duplicate risk, the event guarantees and the open questions. Those decide the contract later.

## How does a service leave the roadmap?

1. The Integration Compiler reads the provider schema, the documents and the event samples.
2. It classifies the side effects, infers the lifecycle and synthesizes the contracts and the tests.
3. The conformance harness runs the false-completion benchmark against the skill.
4. The compiler certifies and signs the manifest. The service then gets a page under /verify.

## Payments

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| PayPal | Payments | An agent captures a buyer payment or sends a refund to a buyer account. | PayPal creates a capture or a refund object and then emits PAYMENT.CAPTURE.PENDING or PAYMENT.REFUND.PENDING, so the record exists and the money has not moved. |
| Plaid | Payments | An agent starts a bank transfer or links a new bank account item for a customer. | /transfer/create returns status pending, and money moves only at an ACH cutoff, while a consumer debit can still return up to 60 days after settlement. |
| Square | Payments | An agent charges a card, refunds a payment, or updates a catalog item in a live Square account. | CreatePayment with autocomplete false returns a payment that is held in an approved state, so the card is authorised and Square has captured no money until an explicit complete call. |
| Paddle | Payments | An agent creates a transaction that bills a customer, or cancels a subscription that a customer pays for. | A cancel call returns HTTP success and creates a scheduled_change, and the subscription status remains active and keeps billing until the effective date passes. |
| Adyen | Payments | An agent authorises, captures, or refunds a card payment through the Adyen Checkout and Modification APIs. | Adyen accepts a capture or a refund request and then sends a CAPTURE_FAILED or REFUND_FAILED webhook when the card scheme rejects it, so the accepted request is true while the money did not move. |
| Wise | Payments | An agent sends a cross-border payout to a recipient bank account. | Wise returns a transfer object with an id while the status is incoming_payment_waiting, so no money leaves the account until a separate fund call succeeds. |
| GoCardless | Payments | An agent creates a direct debit mandate and collects a payment, so money leaves the bank account of a real customer. | A created payment returns status pending_submission, so no money has left the customer account, and the collection takes several business days; a confirmed payment can still move to late failure or charged back, so confirmed alone does not prove that the merchant keeps the money. |
| Braintree | Payments | An agent charges a stored payment method, or it refunds a settled transaction. | A charge returns SUBMITTED_FOR_SETTLEMENT and the money has not moved, and the transaction can still become SETTLEMENT_DECLINED, which the documentation says can even follow a transaction_settled webhook when the bank returns the refund. |
| Razorpay | Payments | An agent captures an authorized payment, or it starts a RazorpayX payout in India. | A payout returns status queued or processing, and the money has not reached the beneficiary, and the payout can still end as reversed or failed. |
| Checkout.com | Payments | An agent captures an authorised card payment or sends a refund to a customer. | The capture returns 202 for a request that is only submitted for clearing, so the money has not moved until the Payment captured webhook reports the updated balances. |
| Lemon Squeezy | Payments | An agent creates a checkout that becomes an order, refunds an order, or cancels a subscription. | The cancel call returns status "cancelled", but the subscription stays valid on a grace period until ends_at, so only status "expired" proves that the customer lost access. |

## Finance

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| QuickBooks Online | Finance | An agent creates an invoice, a bill, or a journal entry in the company ledger. | A create call returns the entity with a new Id while the customer receives nothing, because QuickBooks mails an invoice through a separate SendEmail operation. |
| Xero | Finance | An agent posts an invoice, a credit note, or a bank transaction into the ledger. | A POST returns an invoice with the Status AUTHORISED and a valid InvoiceID, but no money arrived: AmountDue still equals the total, and only an applied Payment moves the invoice to PAID. |
| Mercury | Finance | An agent sends an ACH payment or a wire payment from a business bank account. | The call returns a transaction in the status "pending" that can still wait for an approval, and a transaction that reached "sent" can later become "failed" or "reversed". |
| Ramp | Finance | An agent issues a virtual card with a spend limit, or submits and approves a reimbursement, and both move company money. | The card request returns a task record, and the card is not usable until the task finishes and the Vault API returns the card credentials. |
| Brex | Finance | An agent issues a card to an employee or sends a vendor payment from a Brex cash account. | POST /v1/transfers answers 200 while the status reads SCHEDULED, PENDING_APPROVAL, or PROCESSING, so the transfer exists while no money reached the vendor, and the terminal status can still become FAILED. |
| Chargebee | Finance | An agent changes a subscription plan or issues a credit note, so a customer bill changes. | Chargebee returns a refundable credit note in status refund_due, and no money has reached the customer payment method yet. |
| Carta | Finance | An agent issues an equity grant or records a stock transfer on the company cap table. | A draft option grant holds no equity, because only a user with full access can issue the draft to the cap table, and the draft alone gives the employee nothing. |
| BILL | Finance | An agent schedules a vendor payment against an accounts payable bill, so real money leaves a company bank account. | A created payment returns SCHEDULED while no money has moved, and the payment can then stop at WAITING_ON_APPROVAL, FUNDING_ON_HOLD, DISBURSEMENT_ON_HOLD, FUNDING_FAILED_ACTION_NEEDED, or CANCELED, so a 200 response with a payment id never proves that the vendor was paid. |
| Avalara | Finance | An agent commits a sales tax document in AvaTax, and it starts a return filing through Avalara Managed Returns. | CommitTransaction returns status Committed, and Committed is a state inside AvaTax, so it is not evidence that Avalara filed a return with the taxation authority. |
| Expensify | Finance | An agent advances an expense report through approval and marks it reimbursed so that money reaches the employee. | A report in the Paid status means only that Expensify sent the payment, and the Withdrawing and Confirmed ACH states still follow before the money leaves the company account. |
| Recurly | Finance | An agent changes a subscription plan or issues a refund on an invoice in Recurly. | A subscription change with timeframe term_end, bill_date or renewal returns 201 while the subscription keeps the old plan, and an invoice refund returns a credit invoice while its transaction status is still pending or processing and can later become declined. |

## Sales

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| HubSpot | Sales | An agent creates a deal, logs an engagement, or enrolls a contact in a marketing sequence inside the revenue system of record. | Creating a deal with a pipeline or dealstage value that is a display name and not an internal id, or with an association that does not resolve, returns an object with an id while the deal sits in the wrong stage or attaches to nobody. |
| Salesforce | Sales | An agent creates or updates an opportunity, a contact, or a task record in the customer database. | The create response carries success true and an id for a record whose fields the org changed after the write, because a validation rule, a duplicate rule, a workflow rule, or an Apex trigger runs on the same save, and field-level security can withhold a field from the caller, so the id proves a row exists but not that it holds the values the agent asked for. |
| Apollo.io | Sales | An agent adds a contact to a sequence, so outbound email starts to reach a real person. | Apollo returns the full campaign object and drops named contacts into skipped_contact_ids with a reason such as contacts_without_email, so it queues no email for those people. |
| Calendly | Sales | An agent books or cancels a meeting, so an invitation reaches a customer calendar. | Calendly returns a booking with a cancel URL, and no invitation reaches the customer, because Calendly fires the email and text notifications only when the event type settings enable them. |
| Pipedrive | Sales | An agent moves a deal to a new pipeline stage and writes an activity on the deal. | PATCH /api/v2/deals/{id} returns success true for a deal whose status is won or lost, so the stage field changes while the deal stays closed and the pipeline outcome does not move. |
| Outreach | Sales | An agent adds a prospect to a sequence, and the platform then sends email from a real mailbox to a real buyer. | A created sequenceState returns state active and links the first step, but no mail leaves the mailbox; the state can later become failed, bounced, or opted_out, and only a mailing in a delivered state proves that a buyer received email. |

## Marketing

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Google Ads | Marketing | An agent changes a campaign budget, a bid, or a campaign status, so the account spends a different amount. | The mutate returns a resource name at once, but the campaign can still fail to serve: primary_status can hold LIMITED, MISCONFIGURED or NOT_ELIGIBLE, and the reference states that a modification to the campaign and its related entities might take a while to be reflected in this status. |
| Mailchimp | Marketing | An agent subscribes an address to an audience and sends or schedules a campaign. | The add member call succeeds with the status "pending", so the address sits in the audience and receives no campaign, because the contact never confirmed the opt-in and timestamp_opt stays empty. |
| Meta Ads | Marketing | An agent pauses or publishes an ad set through the Marketing API and changes the daily budget that Meta spends. | The status field is set at the ad set level and can differ from effective_status, so an ad set with status ACTIVE can read IN_PROCESS, WITH_ISSUES or CAMPAIGN_PAUSED and spend nothing. |
| Klaviyo | Marketing | An agent subscribes a profile to a list or creates an event that triggers a flow, and the flow sends email and SMS to buyers. | The subscribe call returns HTTP 202, and a list with double opt-in sends a confirmation message instead, so the profile stays unsubscribed until the person confirms. |
| Customer.io | Marketing | An agent sends a transactional message to one person, or triggers an API broadcast to a segment. | The send endpoint returns 200 when Customer.io queues the message, and the message can still end in bounced, dropped, failed or undeliverable. |
| LinkedIn Ads | Marketing | An agent activates an ad campaign or edits its daily or total budget in a LinkedIn advertising account. | The API returns 204 for status ACTIVE, but the campaign serves no ad when the service sets a servingStatuses hold such as CAMPAIGN_START_DATE_HOLD, CAMPAIGN_TOTAL_BUDGET_HOLD or ACCOUNT_SERVING_HOLD. |

## Communication

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Slack | Communication | An agent posts a message to a channel or sends a direct message to a person, and every reader sees it at once. | Slack returns HTTP 200 for a refused post and puts ok false with an error such as not_in_channel, channel_not_found, is_archived or restricted_action in the body, so a caller that checks only the transport status reports a delivered message that nobody received. |
| Gmail | Communication | The agent sends an email to a customer from the company domain. | users.messages.send returns a Message id and a SENT label for a message that the receiving domain later rejects, because the Message resource carries no delivery field and no bounce field, so the acknowledgement proves only that Gmail queued the message. |
| Twilio | Communication | An agent sends an SMS, a WhatsApp message, or places a call to a real phone number. | Twilio returns HTTP success with status queued or accepted, and even status sent means only that Twilio handed the message to the carrier, so the message can still end at status undelivered or failed after the API call already succeeded. |
| Google Calendar | Communication | An agent creates, moves, or cancels an event and mails the invitation to every guest. | The insert call returns an event while the sendUpdates parameter decides the mail, so a created event can reach no guest inbox and the API exposes no delivery field. |
| SendGrid | Communication | An agent sends a transactional email to a customer address. | HTTP 202 states only that SendGrid accepted the message for processing, and processed, delivered, deferred, bounce, blocked, and dropped are separate later events. |
| Amazon SES | Communication | An agent sends an email through the account, and the send request consumes the sending quota of the account. | The SendEmail reference states that SES can accept a message without sending it, for example when an attachment carries a virus or when a templated email carries invalid personalisation content, so a 200 with a MessageId can pair with a Reject or a RenderingFailure event. |
| Zoom | Communication | An agent creates a meeting and must get the join link to external guests. | Zoom returns a meeting object with a join URL, and that object proves nothing about the guests, because the meeting record carries no delivery state for any invitation. |
| Discord | Communication | An agent posts a message or changes a member role in a public community server. | The add role endpoint returns 204 with an empty body, so the caller holds no state at all and must read the member object to prove that the member now carries the role. |
| Microsoft Teams | Communication | An agent posts a message to a team channel or sends a message in a chat with a colleague. | The chatMessage resource carries a policyViolation property that a data loss prevention application sets after the post, so the API returns 201 with a message id while Teams blocks the content from the readers. |
| PagerDuty | Communication | An agent triggers, acknowledges, or resolves an incident that pages a person at any hour. | The Events API v2 is asynchronous and returns 202 Accepted for an accepted event, and the trigger page states that an acknowledge or resolve event without a currently open alert creates no alert, and that PagerDuty drops an acknowledge or resolve event that a different routing_key sends, so the caller reads 202 while no alert changed. |
| Postmark | Communication | An agent sends a transactional email through Postmark, and the provider reports the delivery or the bounce later. | The batch endpoint returns a 200-level status while an individual message failed validation and was never queued, and a single 200 only proves that Postmark accepted the message, not that the recipient server accepted it. |

## Support

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Intercom | Support | An agent replies in a conversation, so the message must reach the customer inbox. | The reference page states that bot or Operator replies to an inbound email conversation are not sent to the customer by default: Intercom stores the reply as an unnotifiable bot comment and generates no seen receipt until an email is delivered. |
| Zendesk | Support | An agent creates a ticket, adds a public comment, or solves a ticket for a customer. | The API sets the status "solved" and returns success, but the ticket is not finished: the documentation states that Zendesk automatically transitions solved tickets to "closed" after a set period, so the terminal state comes from an automation and not from the call. |

## Developer tools

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| GitHub | Developer tools | An agent opens a pull request, merges a branch, or starts a release workflow in a repository that people ship from. | Creating a pull request returns mergeable null, because GitHub states that it starts a background job to compute mergeability and that the caller must give the job time and resubmit the request, so the response proves a pull request exists but not that it can merge. |
| GitHub Actions | Developer tools | An agent triggers a workflow run that builds, tests, and deploys code to a real environment. | The dispatch call returns a run id while status is still queued or in_progress, and even a completed run carries a conclusion that can be failure, cancelled, timed_out, skipped, neutral, stale or action_required, so neither the dispatch response nor the word completed proves that the deploy reached the environment. |
| Sentry | Developer tools | An agent resolves, archives, or assigns error issues and creates release markers that gate alerting. | A create release call answers HTTP 201 while it creates no deploy, so a rule that waits for a deploy still sees nothing. |
| Datadog | Developer tools | An agent creates or mutes monitors and changes alert thresholds that page an on-call engineer. | A downtime silences the alerts and the notifications of a monitor but does not prevent monitor state transitions, so the monitor reaches Alert and no person is paged. |
| npm Registry | Developer tools | An agent publishes, deprecates, or unpublishes a package version that other build systems install. | A publish with a tag other than latest succeeds, and every consumer that installs without a version still receives the old version under the latest tag. |
| Jira | Developer tools | An agent creates an issue, transitions an issue, or writes a comment in a Jira Cloud project. | The create issue response carries a transition field that the specification defines as the response code and the messages of the requested transition, so a 201 can pair with a failed transition and leave the issue in the default start step. |
| Linear | Developer tools | An agent creates an issue, changes the state of an issue, or assigns an issue to an engineer. | The GraphQL endpoint returns HTTP 200 together with an errors array, so a caller that reads only the status code treats a rejected mutation as a created issue. |
| Asana | Developer tools | An agent creates a task or marks a task complete in a shared project. | The task reference states that approval_status is kept in sync with completed, and that every status except pending maps to completed true, so a completed approval task can carry the status rejected or changes_requested and the approval did not happen. |
| GitLab | Developer tools | An agent pushes commits, opens merge requests, and starts pipelines that deploy to a real environment. | The pipeline endpoint returns 201 with status pending and the deployment endpoint returns a deployment with status created, so the call succeeds while no job has run and nothing has reached the environment; the deployment can still end as failed, canceled, or blocked on an approval. |
| LaunchDarkly | Developer tools | An agent turns a feature flag on for a segment, which changes the behavior of the product for real users. | A 200 response proves that LaunchDarkly stored the new flag configuration, and it does not prove that any SDK client serves the new variation; the reference page for the patch method states nothing about the time until an SDK client receives the change, and a cached or disconnected SDK keeps the old value. |
| Docker Hub | Developer tools | An agent pushes or deletes an image tag, and production clusters pull that tag on the next deploy. | A push writes the blobs and the manifest in separate calls, so an accepted blob upload leaves the tag still pointing at the old digest until the manifest PUT lands. |
| Grafana Cloud | Developer tools | An agent changes alert rules, mute timings and silences that decide when a team sees an outage. | The provisioning API returns 201 for an alert rule, but no person is paged when the rule carries isPaused true, or when the labels of the rule match no notification policy route and reach no contact point. |

## Infrastructure

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Amazon Web Services | Infrastructure | An agent creates, changes, or deletes production resources such as EC2 instances, IAM policies, and Lambda functions. | RunInstances returns HTTP 200 with instanceState pending, and Invoke with InvocationType Event returns HTTP 202 that AWS states does not reflect function errors, so both calls succeed before any compute has done work. |
| Amazon S3 | Infrastructure | The agent writes or deletes an object in a bucket that a production system reads. | A PutObject returns HTTP 200 with an ETag for a write that a concurrent writer overwrites a moment later, so the same key already serves different bytes to the production reader while the caller holds a successful response; in a versioned bucket only the returned x-amz-version-id ties the response to the bytes that the caller wrote. |
| Cloudflare | Infrastructure | An agent changes DNS records, WAF rules, Worker code, and cache state for a live production domain. | A purge call and a DNS write both return success true while resolvers and browser caches still serve the old value for the TTL. |
| Google Cloud Platform | Infrastructure | An agent provisions or deletes projects, Cloud Run services, GKE clusters, and IAM bindings. | setIamPolicy returns the new Policy while Google states that an access change needs about two minutes, and can need seven minutes or longer, to take effect. |
| Vercel | Infrastructure | An agent triggers a deployment, promotes it to production, or changes an environment variable. | A production deployment can hold readyState READY while readySubstate is STAGED, so the build succeeded but the deployment serves no production traffic until a promote step makes it Current. |
| Microsoft Azure | Infrastructure | An agent creates resource groups, deploys App Service apps, and grants roles in a live subscription through Azure Resource Manager. | Azure Resource Manager returns HTTP 201 with provisioningState Accepted, and the deployment can still reach Failed or Canceled at the Azure-AsyncOperation URL. |
| HCP Terraform | Infrastructure | An agent queues a run and confirms the apply, which creates and destroys real infrastructure across cloud providers. | The apply action returns HTTP 202 with no object in the body, and the run can then reach errored, canceled, or force_canceled after Terraform already created or destroyed part of the infrastructure. |
| DigitalOcean | Infrastructure | An agent creates or destroys droplets, App Platform apps, and managed databases in a live account. | The create droplet specification states that the 202 Accepted code does not indicate the success or failure of the operation, and that the caller must read the action in the links object to learn the result. |
| Fly.io | Infrastructure | An agent deploys a machine image, changes machine regions, and sets application secrets for a running application. | The create or update call returns a Machine object while the machine state is still creating or starting, so the returned state is not proof that the process serves traffic or that the health checks pass. |
| Netlify | Infrastructure | An agent starts a build, publishes a deploy, and changes the domain and the redirect rules of a live site. | A deploy reaches state "ready" while published_at stays empty, because the deploy is a draft or a locked deploy stops auto publishing, so the live site keeps the old files and the old redirect rules. |

## Data

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Notion | Data | An agent creates or edits a page in a shared workspace that the team treats as the record. | A markdown page create returns HTTP 202 with a queued async_task, so the call succeeded and the page content does not exist yet. |
| Google Drive | Data | An agent uploads a file or changes a sharing permission on a document that other people must open. | A permission create returns a Permission object, and that object proves a grant record only, not that the named person can open the file. |
| Google Docs | Data | An agent writes text into a shared document that other people read and approve. | The reference page states that the document might not exactly reflect the changes, because other users may edit the document at the same time, so a successful atomic batch can still place text at a shifted index. |
| Google Analytics | Data | An agent sends Measurement Protocol events into a GA4 property and changes the numbers that the business reports. | The Measurement Protocol does not return HTTP error codes, even if an event is malformed or missing required parameters, so the call succeeds and the property records nothing. |
| Supabase | Data | An agent applies database migrations, writes row level security policies, and writes rows in the production project. | A CREATE POLICY statement succeeds while row level security is disabled on the table, and a table in an exposed schema without row level security is readable and writable by any role with a grant on it. |
| Segment | Data | An agent sends track and identify calls that Segment fans out to every connected destination. | Segment returns 200 for a call that it does not accept, for example a call with no userId and no anonymousId or a track call with no event name, so a 200 can pair with zero events at every destination. |
| PostHog | Data | An agent captures product events or edits a feature flag that switches production behavior. | PostHog returns HTTP 200 for an event that it drops, for example an event with an empty distinct_id or an event above the billing quota. |
| Confluence | Data | An agent publishes or edits a wiki page that the company reads as documentation. | A create call that sets status to draft returns a page object with an id, and no reader can see the page, because Confluence never published it. |
| MongoDB Atlas | Data | An agent creates clusters, changes network access rules, and writes or drops collections in production data. | The IP access list page states that after you remove an entry, existing connections from the removed address may stay open for a variable amount of time, so the API reports the rule change while the removed address still reads and writes data. |
| Amplitude | Data | An agent sends event and user-property data into a product analytics project, and teams then make decisions from that data. | A 200 response reports events_ingested, but Amplitude drops an event with an invalid device or user ID without an error, and it ignores a repeated insert_id on the same device for seven days, so the caller reads success while the project holds no new event. |
| Neon | Data | An agent creates branches, runs migrations, and deletes databases in a serverless Postgres project. | A create branch call returns 201 while the branch current_state is init and the branch cannot answer a query; the create_branch and start_compute operations can still end as failed, error, or cancelled, so the caller reads success while the database does not exist for a client. |
| Firebase | Data | An agent deploys hosting content and security rules, and writes documents that mobile clients read at once. | A created hosting version and a created ruleset both return success while the site still serves the old files and the old rules stay in force, because only a release makes a version or a ruleset active, and a rules release needs several minutes to propagate. |
| Qdrant | Data | An agent writes or deletes points in a collection, and a live retrieval path queries that collection. | Without the wait parameter the API returns status acknowledged, which the reference defines as saved to the write-ahead log and queued, so the point is not yet an applied change. |
| Google BigQuery | Data | An agent runs load, insert and delete jobs that change analytics tables and spend the query budget. | jobs.insert returns a job reference before the job runs, and a job that reaches status.state DONE can still carry status.errorResult, so DONE alone does not prove the table changed. |
| Dropbox | Data | An agent uploads a file to Dropbox and creates a shared link that people outside the team can open. | The API returns a shared link, but an external person cannot open it, because the resolved visibility depends on the team settings and the shared folder settings and can fall back to team_and_password, shared_folder_only, no_one or only_you. |

## Identity

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Auth0 | Identity | An agent creates a user, assigns a role, or revokes a session in the login system of the tenant. | The revoke session endpoint answers 202 accepted, so the request is recorded while the session and its refresh tokens can still exist at the moment of the answer. |
| Okta | Identity | An agent assigns an application to a user or deactivates an account, and the access of that person changes. | The application user object answers 200 while status reads PENDING or STAGED and syncState reads SYNCING or ERROR, so the assignment exists in Okta while the downstream application account does not. |
| Clerk | Identity | An agent creates a user, changes an organization membership, or revokes a session in the identity provider of a live application. | The how Clerk works page states that JSON Web Tokens cannot be revoked and that Clerk limits the session token lifetime to 60 seconds, so the revoke call reports a revoked session while an already issued token still authenticates requests until it expires. |
| WorkOS | Identity | An agent creates an SSO connection or provisions a directory user for a customer tenant, so real employees gain or lose access to the application. | A portal link returns successfully while no connection exists yet, because the IT contact of the customer must finish the setup, and the link expires after five minutes; a connection in state draft or requires_type also exists without the ability to authenticate a user. |

## Human resources

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Gusto | Human resources | An agent submits a payroll run that moves money to employees. | The submit call returns HTTP 202 and moves the payroll to the processed state, but the documentation states that async errors appear only after the async processing ends, so the caller must poll and the payment can still fail. |
| Rippling | Human resources | An agent submits earnings into a payroll run or writes a variable compensation payout for an employee. | A payroll run in runState APPROVED means only that the administrator approved the run before the check date, and the same run can later read FAILED, which the specification defines as the check date arrived and the run was not paid. |
| Deel | Human resources | An agent creates a contractor agreement or adds a payment against a contract invoice. | The create contract call returns 201 with status new or waiting_for_contractor_sign, so the contract exists in Deel while no worker signed it and no work is authorised. |
| Greenhouse | Human resources | An agent advances a candidate to the next interview stage, or it rejects an application and sends a rejection email. | The reject call returns status rejected at once, and a rejection_email with a future send_email_at means the applicant has not received any message yet. |
| ADP | Human resources | An agent posts a pay data batch or changes the base remuneration of a worker in ADP. | The pay data batch enters the payroll worksheet, but no worker receives money until the payroll job status moves from Awaiting Commit (F01) to Committed (M99) or Payrun Complete (Z99). |

## Legal

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| DocuSign | Legal | An agent sends an envelope for signature to a named signer. | The envelope status page defines sent as an email notification with a link sent to at least one recipient, and it defines delivered as all recipients viewed the documents through the DocuSign signing website and states that delivered does not indicate an email delivery, so both statuses report progress while no person signed. |

## AI

| Service | Category | What an agent does there | What the acknowledgement does not prove |
| --- | --- | --- | --- |
| Anthropic | AI | The agent submits a message batch or uploads a file, and the account pays for the run. | A batch create returns HTTP success with processing_status in_progress and zero results, and Anthropic states that a batch can run for up to 24 hours and that requests still inside it at that point end as expired, so the acknowledgement never proves that any request reached the model. |
| OpenAI Platform | AI | An agent starts fine-tuning jobs and batch jobs that consume paid quota. | A batch reaches the status "completed" while request_counts.failed is above zero, and a batch that passes the 24 hour window becomes "expired" but still bills the requests that already ran. |
| Google Vertex AI | AI | An agent starts a batch prediction job or deploys a model to an endpoint that bills for each node hour. | A batch prediction job can end in JOB_STATE_PARTIALLY_SUCCEEDED, which the discovery document defines as some results missing because of errors, so the job ends without an error while the output is incomplete. |
| Amazon Bedrock | AI | An agent starts a batch inference job or sets a model invocation log configuration that bills the account. | CreateModelInvocationJob returns a jobArn while the job status is only Submitted, and the job can then reach Validating, Scheduled, Expired, Failed, or PartiallyCompleted, so the account holds a job identifier and no inference output. |
| OpenRouter | AI | An agent sends a paid completion request that OpenRouter routes to an upstream model provider and bills to the account. | A streaming request receives HTTP 200 before the model writes a token, and a provider failure then arrives as a mid-stream server-sent error event that ends the stream, so the caller reads a 200 while no usable completion exists. |
| LangSmith | AI | An agent writes traces, updates datasets, and starts evaluation runs that gate a model release. | Run ingestion answers 202 Accepted and the JavaScript SDK sends batches on a background thread, so a process that exits early loses spans and the experiment reports fewer runs than the agent produced. |

### Can I verify a roadmap service today?

No signed skill exists for it. Run `provely skill generate --openapi <url>` to draft a skill from a schema, review the uncertainties, and run the conformance matrix.

### Does the order of the roadmap promise a date?

No. The order states the priority that the dossiers record. Provely publishes a service only after the conformance matrix passes.

## Read next

- [Read which integrations Provely verifies today](https://provely.sh/verify)
- [Read the false-completion benchmark](https://provely.sh/benchmark)
- [Read what a completion contract contains](https://provely.sh/contracts)