Terms of Service

1. These terms, and who they apply to

These terms cover your use of Pintle, an API that runs your agent skills when you call it, using prompts in your repository, credentials you send with each run, and run logs saved to storage you own. They are a contract between Pintle Ltd, of 22 Lower Baggot Street, Dublin 2, D02 Y243, Ireland (“Pintle”, “we”) and the company that signs up (“Customer”, “you”).

The service is for businesses only, not consumers. By signing up you confirm that you are acting for your business and that you have the authority to commit your company.

The person who accepts these terms accepts them for the company, not for themselves. If you don’t have that authority, please don’t go ahead.

If documents disagree. This order applies: (1) a signed order form or agreement between us, (2) the data processing agreement, (3) these terms, (4) our Privacy Policy, (5) anything else on our website.

2. What the service is

The API: one endpoint to start a run, one to replay a run and one to refresh your issue index, versioned in the path. The prompt folder format and three sample folders (incident triage, PR drafting, page updates) that you copy into your repository and edit. The matcher, which proposes instead of acting when it is unsure. Run logs streamed to the storage you named and confirmed before the run returns. Sandbox keys, a spend cap on every key, and twelve months’ notice before an API version is retired.

3. What the service is not

These limits are deliberate, and they are part of what you are buying. They are not defects.

Not a chat bot you mention. Nothing runs unless something you control calls the API. We don’t listen in Slack, Teams, GitHub, Linear or Discord, and mentioning Pintle in a thread does nothing. The product this site compares itself with works exactly that way, and a team that wants a teammate to talk to should keep it.

Not a connector host. We don’t hold OAuth access for you. You register your own GitHub, Linear and Slack apps, create the tokens and send them with each run. A run acts as your app, under your app’s name. If you haven’t given us the means to act, we can’t.

Not a memory. Pintle doesn’t learn your triage rules by watching. The only thing that builds up is the recorded match decisions that tune your matching. Everything else the agent knows is in your prompt folder or the input. A rule nobody wrote down is a rule the agent doesn’t have.

Not a workspace assistant. No Gmail, Google Docs, calendar or meeting-notes integration, and no schedule of its own. Pintle drafts pull requests, files issues and updates pages when called. It doesn’t turn a meeting into action items.

4. What you need to do, and why it matters

What you get from the service depends a lot on things only you control. Please read this section carefully, because sections 9 and 10 build on it.

The prompt folder is yours. It lives in your repository, changes go through your review, and each run pins a commit. If the folder fails to parse, the run fails. We don’t fall back to an older version, because we cache none.

The rules have to be written down. The agent knows only what your prompt folder and the input say. Rules your previous tool picked up by watching have to be written down by someone on your team. That is most of the first week’s work.

Tokens are yours to create and limit. Create tokens from your own apps with the narrowest permissions the skill needs, short-lived where the tool allows, and send them with each run. We never ask for more than the sample folder documents.

The storage for run logs is yours. You set up the storage or webhook and keep it reachable. If it doesn’t confirm, the run is marked unrecorded, returns an error and costs no credits. We don’t run unrecorded.

Proposals need a person. Below the confidence threshold Pintle returns candidates and stops. Your pipeline has to send that result to someone who can decide, or those runs end with no issue filed.

Put a spend cap on every key. Set a credit cap per key. A pipeline that calls the API in a loop spends credits until the cap stops it, and we don’t refund credits a misconfigured job burned.

5. Getting started, and what is free

A sandbox key comes with 5,000 credits, for a work email and a company name. No card.

Sandbox runs are full runs: the same API, the same models, the same run logs. The only limits are the credit balance and ten runs at once.

Sandbox credits don’t expire while the key is unused. Your first purchase upgrades the same key, with no new setup.

6. Fees

Per credit, prepaid. EUR 40 buys 10,000 credits. One credit is 1,000 tokens through the API, input and output together, whichever model served the run. Larger packs cost less per credit. Those prices are on the pricing section of the site and nowhere else.

What is never charged. Tool calls, replays of a stored run, prompt folder fetches, index refreshes and run log delivery cost no credits. There is no organisation fee, no seats, and no charge per key or per key holder.

Credits last twelve months. From the date of purchase. You can see the balance and the cap on each key. A run that would exceed the balance is refused before it starts, never half-run.

Refunds and VAT. Unused credits from a first purchase are refunded in full on request within thirty days. Invoices come from an Irish company with an Irish VAT number. EU business customers with a valid VAT number are reverse-charged.

7. Delivery, availability and support

API versions. The API is served at a versioned path. We retire a version only with twelve months’ written notice, and the old version keeps working until the date in that notice.

The run log comes first. A run returns 200 only after the storage you named has confirmed the last line of its log. A run whose log could not be delivered is marked unrecorded, returns an error and is not charged.

The folder format is public. The prompt folder format is published under a permissive license. The folder in your repository stays readable, and runnable by something other than us, if we ever stop.

Support. Support is by email at [email protected]. We aim to reply within one business day. That is a target, not a guarantee.

8. Runs, run logs and replays

A run log is never edited. It holds every model call, tool call and result, in order, with the commit and model version that served the run. We don’t edit a log after it is written. A correction is a new run.

A replay is a new run. A replay reruns a stored log against a different commit or model. It gets its own id and links to the run it came from. The original is untouched.

Our copy is short-lived. We keep a run log for seven days, for support and replay. There is no export to ask for, because the record reached your storage before we confirmed the run.

9. What we promise, and what we don’t

We promise to provide the service with reasonable skill and care, and that we have the right to provide it.

We promise that the API behaves as its published reference says, that a run acts only with the tokens it was given and only through the tools your prompt folder names, that no run is confirmed before its log is delivered, and that below the confidence threshold Pintle proposes and does not file. We don’t promise that a filed issue is the right issue, that a drafted pull request compiles or can be merged, or that a match above the threshold is correct. Those are the calls your reviewers are there to make.

Beyond that we give no other warranty. As far as the law allows, we exclude all implied warranties, including merchantability, fitness for a particular purpose and non-infringement.

10. Liability

10.1 Neither of us limits liability for death or personal injury caused by negligence, for fraud or fraudulent misrepresentation, or for anything else the law says can’t be limited.

10.2 Losses neither of us covers. Neither of us is liable for lost profit, revenue, expected savings, business, goodwill or reputation, or for any indirect or consequential loss, however it arises.

10.3 Specific exclusions. We are not liable for the results of what we deliberately don’t do. We don’t listen for mentions, so we are not liable for an incident nobody called us about. We keep no memory, so we are not liable for a rule nobody wrote down. We don’t merge, close or assign, so we are not liable for what your reviewers merged. We are also not liable for credits spent inside a cap you set, for storage you left unreachable, or for what a hosted model wrote, beyond the promises above.

10.4 Cap. Our total liability is capped at the value of the credits you bought in the twelve months before the claim. If a run was defective, the remedy is that run’s credits back and a fixed release. If a format change breaks your runs, the remedy is the twelve months’ notice, with the old version working until it ends.

10.5 You accept that the limits in sections 9 and 10 are a fair way to share risk, given the price and your part under section 4, and that we could not offer the service at this price without them.

11. Confidentiality and data

The fact that you are a customer is confidential unless you tell us otherwise in writing. We publish no customer names, logos or case studies. Your run inputs, run logs and prompt folders are your confidential information, and we treat them that way for the seven days we hold any of them. After that, the only thing of yours we hold is the account record.

How we handle personal data is set out in our Privacy Policy and in the data processing agreement between us, which forms part of these terms. If the DPA and these terms disagree about personal data, the DPA wins.

12. Who owns what

The runtime, the matcher, the API and the three sample prompt folders are ours. You get a license to use them, not ownership.

Your prompt folders, run inputs, run logs and recorded match decisions are yours.

The prompt folder format is published under a permissive license, so it works without us.

Issues filed, pages updated and pull requests drafted through Pintle belong to you, along with anything built from them.

You may not use our name or logo in public, and we may not use yours, without written permission first.

13. How long this lasts, and how it ends

13.1 The contract starts when you sign up and runs until one of us ends it.

13.2 You can end it. Cancel at any time. It takes effect at the end of the current billing month, unless section 6 sets a minimum term.

13.3 We can end it. We can end it with 30 days’ notice. We can end it immediately if you seriously break these terms and don’t fix it within 14 days of being told, if you become insolvent, or if your use exposes us to legal risk.

13.4 What happens then. We stop delivering and stop billing. You keep everything already delivered to you, and your right to use it continues. We delete or return our working copies as the DPA says. Sections 9, 10, 11 and 12 continue to apply.

14. Changes to these terms

We may update these terms. A change that matters takes effect 30 days after we email you about it. If you don’t accept it, you can end the contract before then. Using the service after that date means you accept the change.

15. Contact

Pintle Ltd, 22 Lower Baggot Street, Dublin 2, D02 Y243, Ireland
[email protected]

← Back