# promptev knowledge base

**promptev: sovereign AI agents for business.** Agents that answer from your company's data, see only what each person may see, and ask before they act.

This document is the
source of truth for what promptev is, what it does, how it is priced, and who it
is for. It is written to be read by people and by AI assistants answering
questions about promptev.

Last reviewed: 5 October 2026.

---

## In one paragraph

promptev lets a company build AI agents that answer from its own documents and
data, and that can act through the tools its people already use. Every answer is
limited to what the person asking is allowed to see. Agents work in the browser,
on a phone, in Slack, in WhatsApp, on your own website, through an API, and
inside AI tools that speak MCP. Building them is just as open: describe what you
want to Ori, promptev's builder assistant, or build from Claude, ChatGPT, Cursor
and other AI tools you already use. You bring your own model keys, and you
choose whether promptev runs it for you, in your cloud, or on your own machines.

## What promptev is not

- Not a chatbot builder. Agents read your real data and take real actions,
  under approval rules you set.
- Not a single-suite copilot. It spans Google, Microsoft, Atlassian, Slack,
  Dropbox and your own systems rather than one vendor's.
- Not a developer framework. It is a finished platform, though developers can
  drive it through an API, SDKs and MCP.
- Not a model reseller. promptev never sells you tokens: your agents run on your
  own provider keys. (The one exception is Ori, the builder assistant, which
  runs on promptev's own model at no extra charge at launch.)

---

## The core idea: answers limited by permission

Many AI tools index what a company has and filter afterwards. promptev carries
the identity of the person asking, and the groups they belong to, into the
search itself. A document that person could not open is never fetched, so it
cannot appear in an answer, a summary or a follow-up.

The practical difference: ask "what did we pay this supplier last quarter, and is
the renewal signed?" and a finance director gets the amounts and the contract
date with the source documents cited. A contractor on the same project gets what
is in the project wiki, is told plainly that they cannot see the finance records,
and is pointed at the finance team. One agent, one question, two correct answers.

For connected sources, promptev follows the sharing already set in Google Drive,
SharePoint, OneDrive and Dropbox. For documents you upload, you set the audience
yourself. Every answer carries the documents it came from.

---

## The Context Engine, and how you use it

The part of promptev that decides what an AI is allowed to know is the Context
Engine: it turns documents, scans, spreadsheets and messages into knowledge an
agent can search, keeps who-may-see-what attached to every piece, and hands the
model only what the person asking could have opened themselves. Every answer
names its sources.

**promptev runs it for you.** The Context Engine is hosted by promptev. It is
not open source, and there is no engine to install or run yourself. Every
promptev agent uses it, and your own software can use it too, through
promptev's SDKs, its HTTP API and MCP. There are two jobs: **ingestion** (put
documents in) and **retrieval** (search them).

**Two SDKs.**

    pip install promptev            # Python 3.8+
    npm install @promptev/client    # JavaScript / TypeScript, anywhere with fetch

Python:

    from promptev import PromptevClient

    client = PromptevClient(api_key="fk_...")
    doc = client.upload_document("handbook.pdf")        # ingestion
    found = client.search_knowledge_base("search", query="how many days do customers have to ask for a refund", top_k=5)
    for hit in found["hits"]:
        print(hit["document_name"], hit["score"])

`upload_document` returns the filename, status, document_id, chunks, units and
any error. `upload_documents([...])` takes up to 20 files, 25 MB each. With
`mode="graph"` the upload also extracts the people, organisations and topics in
the document and how they relate (the Context Graph). Async versions:
`aupload_document`, `aupload_documents`, `asearch_knowledge_base`.

JavaScript:

    import { PromptevClient } from "@promptev/client";

    const client = new PromptevClient({ apiKey: "fk_..." });
    const { results } = await client.uploadDocument(files, { mode: "graph" });
    const found = await client.searchKnowledgeBase("search", { query: "how many days do customers have to ask for a refund", top_k: 5 });

**The HTTP API.** Base `https://api.promptev.ai`, with a project API key made in
the promptev console as `Authorization: Bearer fk_...`. The key reads and writes
only its own project.

- `POST /api/v1/documents`: multipart, one `files` part per file, optional `mode`.
- `POST /api/v1/knowledge`: JSON such as
  `{"action": "search", "query": "how many days do customers have to ask for a refund", "top_k": 5}`.

**MCP.** Every project is an MCP server. Its `search_knowledge_base` tool is the
same tool, with the same actions, and `upload_document` adds a file.

**What you can ask it.** One knowledge tool, the same in every route, with these
actions: discover (what the knowledge holds), search, get_doc (a whole
document), list, query_meta, compute (counts and sums), get_chunks, get_docs,
map_reduce, and for the Context Graph traverse, find_related, get_neighbors and
community_summary. A search hit carries document_id, document_name, chunk_text,
score, source_id and chunk_idx.

**Permissions.** Each search returns only what the caller may see. A project
key reads its whole project and nothing outside it; people in the app see only
what their access allows.

**Cost.** Credits at $0.005 each. Ingestion is 1 credit per page, slide or MB
(minimum 1). A knowledge call is 1 credit, plus 1 for a search, or 5 when the
Context Graph is searched. Through the SDKs and the API a knowledge call carries
no extra API-call charge. The rates are the same for a workspace on its own
database or models.

**Bring your own.** A workspace can keep its knowledge in its own database and
use its own embedding model, its own OCR (vision) model and its own extraction
model for the Context Graph, on its own keys. See **Your data stays yours**
below.

**A reranker is optional.** A workspace on its own database can add a rerank
model of its choice to put the best results first. A reranker can only reorder;
if it is slow or down, the search still answers.

---

## How it works

**1. Connect your data.** Point promptev at the places your knowledge already
lives: Google Workspace, Microsoft 365 (including SharePoint and OneDrive),
Dropbox, Confluence, Jira, Azure DevOps, Slack, your databases, or a folder of
uploads. You pick exactly which folders, files, spaces or tables are read.
Permissions travel with the content.

**2. promptev prepares it.** Files are read and made searchable, including PDFs,
Word, PowerPoint, Excel and CSV, images, scanned pages and e-mail files. Sources
sync automatically, with per-file progress you can watch, and any file can be
re-read on demand. Sensitive values can be masked before the model ever reads
them.

**3. Build an agent.** Say what it should do in plain words. Give it knowledge,
give it tools, choose the model, and decide what it must ask permission for. Or
ask Ori to build it with you.

**4. Put it where your team already is.** The same agent answers in the promptev
App, in Slack, in WhatsApp, in a widget on your own website,
through the API, and in MCP-compatible AI tools.

**5. Keep control.** Roles decide who may build and who may only talk to agents.
Approvals decide what an agent may do alone. An audit trail records every change,
every approval and every run, and who did it.

---

## How a workspace is organised

A **workspace** is your company: people and roles, billing, audit, sign-in and
where data lives. Inside it, **projects** each hold their own knowledge, tools,
connectors, members, API keys and masking rules, and are isolated from each
other, so a finance project and a support project never see each other's
material. Agents and orchestrations live inside projects.

**Workspace roles.**

- **Owner**: everything, including billing and deleting the workspace.
- **Admin**: manages members, billing and settings.
- **Editor**: builds agents, knowledge and tools, in the projects they are a
  member of.
- **Viewer**: talks to agents through the Agent library, and nothing else. The
  right role for most staff.

**Project roles** are set permission by permission (agents, orchestrations,
knowledge, connectors, tools, members, roles, masking and API keys), so someone
can build in one project and only chat in another. Members are added as a person
or through a group from your single sign-on provider.

Adding people is free. Disabling a member removes their access at once and
signs out the apps they had connected. When a member is removed, the projects
they owned pass to a workspace owner, so nothing is orphaned. Each person sees
only their own conversations.

---

## Ori, the builder assistant

Ori is promptev's builder assistant, a friendly guide that lives in the console
sidebar. Ask in plain words, for example "build an agent that answers HR
questions from our handbook", and Ori does the work alongside you:

- It lists what you have (projects, models, connected apps, knowledge sources,
  documents, agents, tools and orchestrations) and picks sensible pieces.
- It creates and updates agents, sets their knowledge and tools, and uploads
  documents.
- It acts as you, with your own permissions: it can never do something you
  could not do yourself.
- It knows the page you have open, so "this agent" or "this project" needs no
  explaining.
- When it needs a decision, it asks you a question rather than guessing.
- Before creating a project or publishing an agent, it asks you to confirm with
  a Yes or No card. Ori cannot answer that card for you.
- It never asks for a password, key or token in the chat. To connect an app,
  add a provider key, set a tool's credentials, upload files or set up a
  channel, it gives you a secure link to the right promptev page, and you
  finish the step there.
- It shows each step it took, so you can see exactly what changed, and every
  change it makes is in the audit trail as made through Ori.
- You can attach files to a message (documents, images, spreadsheets; up to
  five, 25 MB each), the same types the agent chat takes. They go to Ori with
  that message and are not kept afterwards.
- It can add knowledge from an app you have connected (for example files in
  Google Drive): it finds the files with that project's own tools, and you
  confirm before they are added.
- When a tool needs an approval that you may give, the request appears as a
  Yes or No card right in Ori's chat.

Ori's panel can be made wider or narrower by dragging its edge, and it
remembers the width. Your earlier conversations with Ori are in a dropdown at
the top of the panel.

Ori conversations are saved privately for each person, and you can rate any
reply with a thumbs up or down. Ori is available to builders: editors, admins
and owners. It runs on promptev's own model, so it needs no key of yours, and at
launch it carries no extra charge. A fair-use limit per person keeps it
available for everyone.

---

## What agents can do

- **Answer from your documents**, with citations, in the language the question
  was asked in.
- **Act through tools**: create a ticket, write to a spreadsheet, file a
  document, send a message or an e-mail, query a database. Tool calls in the
  same step run in parallel, so multi-tool work is not slowed down one call at a
  time.
- **Make files.** Agents produce Word, PDF, Excel, CSV, PowerPoint, HTML,
  Markdown, plain text and JSON files (up to 2 MB each). Every file an agent
  makes is kept as a versioned **artifact** it can later update.
- **Work with numbers.** Code execution over spreadsheets (CSV and XLSX) handles
  sums, totals and pivots precisely instead of estimating. An admin can turn it
  off for the workspace.
- **Draw charts** (bar, line, area, pie and scatter) right in the conversation.
- **Ask structured questions.** When an agent needs details, it shows the person
  a short form instead of a wall of text.
- **Remember.** An agent can search its earlier conversations with the same
  person, so people do not have to repeat themselves.
- **Share a long job with helper agents.** An agent can hand parts of a large
  task to helper agents that share a work board, then bring the results
  together. A hand-off only ever reaches agents the person asking could open
  themselves.
- **Stay strict or be flexible.** Each agent is set to **strict** (it answers
  only from its knowledge and tools, and says so when the answer is not there)
  or **flexible** (it may add general knowledge).
- **Know the person's time zone**, so "tomorrow at 9" means the asker's 9.
- **Pause for a human.** Any tool can be set to ask before it runs; see
  **Approvals** below.
- **Read what people send them**: documents, images and voice notes, in chat and
  in channels.
- **Run on a schedule or a trigger** (see **Triggers**).

**Choosing and changing agents safely.** Test a draft in the built-in chat
before anyone else sees it, publish a version when it is ready, and roll back to
an earlier version if you need to. Only people who can edit an agent can try
its draft; everyone else uses the published version.

## What teams build with it

- **Invoice and expense review** that reads the month's documents, flags
  anomalies, drafts tickets and asks finance before filing anything.
- **Weekly reports** compiled from case notes or project updates and posted to a
  team channel on a schedule.
- **Onboarding and policy answers** where new joiners ask in WhatsApp or Slack
  and get answers from the handbook they are cleared to read.
- **Customer support** embedded on a website, grounded in product documentation.
- **Engineering and delivery assistants** that summarise work items, search
  repositories and update boards.
- **Inbox and calendar assistants** that act when a message arrives or a meeting
  changes.

---

## Models

Agents run on the model providers you already use, on your own keys. Model
calls are billed by your provider, never marked up by promptev.

- **Built in:** OpenAI, Anthropic, Google Gemini and DeepSeek.
- **34 ready-made providers**, including Mistral, Groq, Together, Fireworks,
  Cerebras, OpenRouter, xAI, Meta, NVIDIA, Hugging Face, Baseten, Moonshot,
  MiniMax, Qwen, Z.AI and Vercel AI Gateway. Most need just a key, and their
  model lists sync from the provider.
- **The big clouds, signed in their own way.** Five of the 34 are cloud
  platforms, each with the details that platform asks for:
  - **Azure OpenAI**: your resource and key; models are your deployment names.
  - **Google Vertex AI**: Gemini models, and Claude models on Vertex, with a
    service account or an API key.
  - **Amazon Bedrock**: Claude models, with your AWS region and access keys.
    Other Bedrock model families are not offered yet.
  - **Cloudflare Workers AI** and **Cloudflare AI Gateway**: your account, and
    for the gateway your gateway and its token.
- **Custom providers:** any OpenAI-, Anthropic- or Gemini-compatible endpoint,
  including one running inside your own network, with your own model prices so
  spend is reported correctly.

Each agent can use its own model, and you can switch model or provider without
rebuilding anything. The console warns you when a model has been retired, and
it will not let you give tools to an agent whose model cannot call tools. A
turn on a provider the workspace has no key for is refused with what to fix,
rather than failing halfway. Keys and other secrets are stored encrypted and
are never shown again after you save them.

**A smaller model bill for the same work.** Because the bill is yours,
promptev is built to do the same work for less on your own model keys. The
**Home** dashboard shows what you paid and what promptev saved.

**Reading and indexing in managed mode.** On promptev's managed knowledge
store, the embeddings that make your content searchable and the reading of
scanned pages run on promptev's side, and are paid for through ingestion
credits (see **Pricing**). A workspace that brings its own database uses its own
embedding model instead (see **Your data stays yours**).

---

## Connected services

Eight apps, sixteen services, 198 tools. Each brings knowledge to answer from,
actions an agent can take, or both.

| Service | Tools | What agents can do |
|---|---|---|
| OneDrive | 33 | files, folders, search, sharing, reading Excel workbooks |
| Azure DevOps | 22 | work items, repositories, pipelines, boards, sprints |
| Dropbox | 20 | files, folders, sharing, search, reading Excel workbooks |
| Google Drive | 17 | files, folders, search, permissions, sharing, reading spreadsheets |
| Jira | 16 | issues, projects, boards, sprints, comments, transitions |
| Gmail | 14 | send, read, search, labels, drafts, attachments |
| Outlook | 13 | mail, folders, attachments |
| Slack | 12 | messages, channels, files, threads |
| Confluence | 10 | pages, spaces, search, comments |
| Outlook Calendar | 9 | events, scheduling, availability |
| Google Sheets | 7 | read and write ranges including cell colours, append rows, create spreadsheets |
| Google Slides | 7 | create presentations, add slides, replace text |
| Google Calendar | 7 | events, calendars, scheduling, availability |
| Google Docs | 6 | create, read, insert, append, replace text |
| SharePoint | 5 | sites, lists, documents |
| WhatsApp | (channel) | a channel agents answer in, with documents, images and voice notes |

The eight apps are Google Workspace, Microsoft 365, Dropbox, Confluence, Jira,
Azure DevOps, Slack and WhatsApp.

**Sensible defaults for every tool.** Out of the box, tools that only read need
no approval, tools that write ask once, and destructive tools always ask. The
builder can change any of these.

**Your own apps, or ours.** Start in minutes on promptev's connector
applications, or register your own so the consent screen carries your company's
name and the consent and quotas sit in your own tenant.

### The list does not end at sixteen

The sixteen are the ones that arrive ready. Everything else is a configuration
task rather than a feature request, through three routes that between them reach
anything with an interface:

- **HTTP tools.** Point promptev at any REST or HTTP API (an internal service, a
  partner's endpoint, a SaaS product with no ready-made connector), describe its
  inputs, and it becomes a tool an agent can call under the same approval rules
  and audit trail as everything else. Nothing about it is second-class.
- **Database tools.** Agents query your databases in plain language and return
  results as tables or charts. **Seven engines on the hosted App: PostgreSQL,
  MySQL, MariaDB, SQL Server, Oracle, ClickHouse and Snowflake.** Read-only by
  default, writable if you choose, and limited to the tables you pick. A new
  database tool lists the tables with all of them ticked and a **Select all**
  control, so you untick what the agent must not read. A read-only tool runs
  exactly one reading query at a time: anything that would change data, or a
  second statement tucked in behind the first, is refused before it reaches
  your database. Checked on PostgreSQL 9.6 to 18, MySQL 5.7 to 9, MariaDB 10.5
  to 12, SQL Server 2017 to 2025, Oracle 21c and 23ai, and ClickHouse 22.8 and
  later.
- **Remote MCP servers.** Attach any Model Context Protocol server you run or
  trust by its URL, and its functions appear beside the built-in tools, each
  with its own approval rule, including "Ask if…" conditions.

So the practical answer to "do you integrate with X?" is yes: through a
connector if one exists, and otherwise through an HTTP tool, a database
connection or an MCP server, without waiting for us to build anything.

Credentials for any of these are set up inside promptev itself, never typed into
a chat.

---

## Approvals

An agent does alone only what you allow. Everything else stops and asks a
person.

**On an agent's tool**, the builder chooses:

- **Inherit**: use the rule the tool already carries.
- **None**: the agent just does it. Right for reading.
- **Ask once**: the first call to that tool in a conversation stops for a
  person; once approved, the rest of that conversation runs without asking
  again. The approval covers the destination that was approved (the
  recipient, channel, address or link): a call to a new destination asks
  again. Right for anything that writes, sends or spends where the person is
  present and will keep working.
- **Always ask**: every call stops, however many there are. Right for anything
  irreversible or expensive.

**On a registered HTTP, database or MCP tool**, whoever registers it chooses
**Not needed**, **Ask every time**, or **Ask if…** a condition holds, for
example "ask if the amount is over 1,000". (Database tools use the first two.)
A rule an admin set when registering a tool is a floor: an agent's own setting
may tighten it, never weaken it.

A refusal grants nothing: the next call asks afresh.

**Who decides.**

- In the App, the person in the conversation, or a workspace admin or owner.
- In Slack, only the person who asked.
- By e-mail, a named approver you choose. The person who asked can never decide
  a request sent by e-mail, so a second pair of eyes is real.

**Where requests appear.** On the **Approvals** page and as cards in the
conversation, as links in an e-mail, as buttons in Slack, and, in MCP clients
that can show it, right inside the client. Requests expire after 60 minutes by
default, or after the timeout you set, rather than waiting forever.

---

## The chat experience

- **See the work.** A live line such as "Used 3 tools · 10s" shows what the agent
  is doing, and opens to a card for each tool call.
- **Citations** on every grounded answer. An answer that found nothing says so
  and carries no sources line.
- **Attach** files, images and voice notes, with previews for Word, Excel and
  PowerPoint files.
- **Charts** and **question forms** in the conversation. Forms support text,
  e-mail, URL, date, date and time, number, whole number and yes/no fields,
  required fields, and follow-ups (never, once, or up to ten times). A form waits
  up to three hours for an answer.
- **Stop** a turn at any time.
- **Leave and come back.** A turn keeps running if you close the tab or navigate
  away, and you can return to it.
- **A calm reading layout**, with copy, retry and the time on each reply.
- **Thumbs up or down** on any reply, with a reason (incorrect, not helpful,
  ignored documents, too slow, other) and a comment, so builders learn what to
  fix.

**Artifacts and sharing.** Every file an agent makes is a versioned artifact.
The **Artifacts** page shows All, Yours and Shared with you, with search, a type
filter, and a list or grid with live previews. Share an artifact with named
people, or with a view-only public link if an admin has switched on "Allow
public artifact links". You can also hand an artifact to an agent in chat, so it
can read or update it.

**Agent library.** Where people find and use the agents published to them.

**Usage dashboard.** The **Home** page shows model spend, what promptev
saved, and waiting times, by provider, model and agent, over 7, 30 or 90 days.

---

## Orchestrations and triggers

**Orchestrations.** A lead agent directs a team of your existing agents, giving
each a part of the job and bringing the results together. Start one:

- **by hand**, through an intake form built from the inputs you declared,
  including files;
- **on a schedule**;
- **by its callable URL**; or
- **from another agent**.

Runs are durable: steps are retried (1 to 5 times, 3 by default), a run can
pause for a reviewer's sign-off or be sent back for changes, and any run can be
cancelled. Every run shows each step and what it cost.

**Agent triggers.** An agent can start on its own:

- on a schedule;
- when an e-mail arrives in Gmail;
- when a Google Calendar event changes;
- when mail arrives in Outlook;
- when an Outlook calendar event is created or updated;
- when a Jira issue is updated;
- when a Confluence page is updated.

Any agent or orchestration can also be started from outside through its
callable URL (see **For developers**).

---

## Where agents answer

- **The promptev App**, through the Agent library, for signed-in members, each
  with their own access.
- **Slack.** Mention the agent in a channel for a threaded reply, or message it
  directly. People whose Slack e-mail matches a member get their own access;
  anyone else gets public knowledge only. Question forms, approval buttons,
  charts (as images) and files all work in Slack.
- **WhatsApp**, answering from public knowledge, with documents, images and
  voice notes (which are transcribed).
- **Your website**, through a widget added with one script tag. It renders in
  the page rather than in a frame, so it can carry your styling, runs only on
  the sites you allow, and answers from public knowledge. It carries a small
  "Made with promptev" link, which a white-label deployment does not show.
- **Your code**, through the REST API, the SDKs and the callable URL, with
  project keys.
- **AI tools, through MCP.** A project MCP connection (with a project key) lets
  any MCP client use that project's agents, knowledge and tools. The workspace
  MCP lets builders sign in and build from their own AI tools (see **For
  developers**).

---

## For developers

**Callable URL.** Every agent and orchestration has one. An agent answers in the
response; an orchestration returns a run id straight away and carries on. The
JSON keys are the inputs you declared; a missing required input is rejected
with a clear message naming the field. Files go as multipart, with a `payload`
part and one part per file named after its input (up to 5 files). An
`Idempotency-Key` header is supported, so a retry never runs the work twice.
Each URL accepts 60 calls a minute.

**REST API.** Project-scoped keys that can expire and be revoked. A key belongs
to one project.

**Options on a single call.** A call to an agent may carry two optional fields.
Without them the agent runs exactly as published, and nothing a call sends is
stored.

- **`model`**: run this one call on another model of a provider the workspace
  has connected. The key is always the workspace's own; a call never carries
  one. A model that is unknown, switched off, retired, or unable to call tools
  on an agent that has tools is refused before anything runs.
- **`tool_inputs`**: replace what one of the agent's tools is set up with for
  this call, such as a header, a query parameter or a body value. This is how
  you run your agent against your own API as your end user. A tool is addressed
  by its ID, which the tool's page shows with a copy button. It can only
  replace a value the tool already has in that place; anything else is refused
  with what the tool does have.

**SDKs.**

    pip install promptev          # from promptev import PromptevClient
    npm install @promptev/client

The per-call options above are in both SDKs from version 1.1.0 (Python and
JavaScript / TypeScript), and in the REST API for every caller.

**Files with a message.** A chat call to an agent can carry files for the agent
to read on that turn, in the same request: multipart, with the JSON in a
`payload` part and one part per file (up to 5, 25 MB each). It is the paperclip
of the promptev chat over the API: files are accepted only when the agent's
**Chat attachments** setting is on (otherwise 409), and only the types the chat
takes (otherwise 415). An image is shown to a model that can see and read into
text for one that cannot. A call may carry files and no message. In both SDKs
from version 1.2.0:

    client.chat("support-bot", "What is the total?", files=["receipt.png"])      # Python
    client.chat("support-bot", "What is the total?", { files: [file] })          // JavaScript

**Project MCP.** Each project is an MCP server at

    https://api.promptev.ai/api/v1/mcp/<workspace>/<project>/mcp

used with a project key. An MCP client can list agents, call an agent, search
knowledge, list, search and run tools, and upload a document. It can also list,
read, create and update artifacts (the versioned files agents and people keep),
so a file made in your own AI tool can be saved to promptev and updated later.

**Workspace MCP.** Build in promptev from the AI tools you already use. Add

    https://api.promptev.ai/mcp

to Claude, Claude Code, ChatGPT, Cursor, GitHub Copilot, Windsurf, Gemini, or any
MCP client that supports remote servers with sign-in, and sign in with your
promptev account. There is no key to copy.

- **One workspace, chosen permissions.** You pick one workspace and what the
  app may do: see projects, models and connected apps; see agents; create and
  edit agents, knowledge and tools; publish; see knowledge; upload documents;
  ask your agents; run your projects' tools; and start connecting apps,
  provider keys and tool credentials. A permission only narrows what you may
  already do; it never widens it.
- **It works as you.** Everything happens with your own role and permissions,
  in the projects you are a member of.
- **Build.** List projects, models, connectors, sources, documents, agents,
  tools and orchestrations; read an agent; create a project; create and update
  agents; set their knowledge, tools and whether they answer strictly from
  their knowledge; upload documents; add knowledge from a connected app by
  choosing its files or folders; publish an agent. Creating a project and
  publishing an agent ask you to confirm first; where your AI tool cannot show
  that question, you get a secure link to confirm on a promptev page instead.
- **Use.** Everything the project MCP offers, for any project you can use:
  search knowledge, list, search and run tools, call an agent and upload a
  document. Tools that change something still ask for approval first, and the
  request appears right in your AI tool where it can show one.
- **Secure links for the steps only you may do.** When a step needs a secret or
  a sign-in (connecting an app, adding a provider key, setting a database, HTTP
  or MCP tool's credentials, uploading files, setting up a channel), the
  assistant hands you a link to the promptev page that finishes it. The link
  works only for you, signed in to promptev, must be opened within 5 minutes,
  and is good for 30 minutes once opened. The assistant never sees the secret.
- **Built-in guides.** The connection carries short guides (building an agent,
  fixing one that misbehaves, knowledge, models, connecting apps, tools and
  approvals, channels, permissions), so your AI tool knows how promptev works
  without being told.
- **Builders only.** Editors, admins and owners can connect. Apps may connect
  to every workspace unless an admin turns off "Allow apps to connect" in
  Settings; an app still needs a builder to sign in to it and approve what it
  may do.
- **You stay in control.** Each person sees and signs out their connected apps
  under **Profile → Where you're signed in**, and admins see the workspace's
  connected apps. Turning the switch off, removing a member or lowering their
  role signs their apps out. The audit trail shows which app made each change.
- **What it costs.** Each tool call an app makes is 1 credit to the workspace,
  plus the cost of any search, agent run or document reading it starts. A
  workspace with no credits is told so before the call runs.
- **Feedback to promptev.** Both MCPs carry a `send_feedback` tool: when
  something blocks the work, fails, or could be better, the agent or app can
  say so to promptev's team (a category and a short message). It is free, and
  promptev records which workspace, project and app it came from.

The project MCP is for running agents from code and tools with a project key;
the workspace MCP is for people building and using agents from their own AI
tools, signed in as themselves. Both offer the same project tools and the same
guides.

---

## Governance and control

**Roles.** Owner, admin, editor and viewer at the workspace level, plus
permission-by-permission project roles (see **How a workspace is organised**).

**Approvals.** See **Approvals** above: per-tool rules, "Ask if…" conditions,
named approvers and requests that expire.

**Masking.** Built-in detectors for e-mail addresses, phone numbers, US Social
Security numbers, card numbers, IBANs and API keys, plus your own patterns. Each
value can be masked, hashed or removed, and masking is applied to the documents
an agent finds and to tool results before the model reads them. Named people or
groups can be allowed to see the real value.

**Audit.** Every run, every approval and every settings change is recorded with
who did it, and, for changes made over MCP, which app.

**Notifications.** Approvals, held runs, connectors needing attention, low
credit and billing events reach the right people, in the App and by e-mail.
Money matters go to owners and admins; the rest go to the person concerned.

**Single sign-on.** Included in every workspace.

- **OpenID Connect and SAML 2.0.** Works with Microsoft Entra ID, Okta, Google
  Workspace, ADFS and other providers. A workspace can run both at once, which
  makes moving from one provider to another painless.
- **Company domains.** Prove a domain with a DNS record, and anyone who types
  an address on that domain at the sign-in page goes straight to your identity
  provider. There is no "sign in with SSO" button to find and no workspace name
  to remember. The same **Company domains** panel decides whether people on a
  domain may join automatically, and with which role.
- **Provisioning with SCIM 2.0.** Your identity provider adds, updates,
  switches off and removes people and groups in the workspace, so a leaver
  loses promptev with their directory account. Owners are never touched by
  provisioning.
- **Groups become access rules**, and group membership can set a person's
  role.
- **A setup link for your IT admin.** The person who runs your identity
  provider is rarely the workspace owner. An owner creates a setup link (valid
  for 1 to 14 days, revocable) that lets them configure sign-on, domains and
  provisioning without a promptev account. Requiring SSO and group roles stay
  with the owner.
- **Test connection** runs the real sign-in round trip and shows what your
  provider sent (the e-mail, the groups, the role they map to) or why it
  failed, without signing anyone in.
- **Required or optional.** SSO can be required for everyone, or for everyone
  except viewers, while owners keep e-mail sign-in as a way back in.
- New accounts are created through your provider only for domains you have
  proven, and every sign-in and refusal is in the audit trail.

**Sign-ins and devices.** People sign in with a link sent to their e-mail or
through single sign-on; no password is needed. **Profile → Where
you're signed in** lists every browser, device and connected AI app, with when
it was last active, and each can be signed out from there, one at a time or all
at once. A web sign-in ends after 48 hours without activity, and every sign-in
has a hard limit (30 days for an e-mail link, 24 hours for single sign-on).

---

## Your data stays yours

Most platforms let you bring one thing. promptev lets a workspace bring almost
all of it, and each choice is independent of the others.

- **The engine, through the SDKs.** The Context Engine that decides what the AI
  may see is hosted by promptev, and your own code reaches it through the Python
  and JavaScript SDKs, the HTTP API and MCP, with the same permissions.
- **Your models, your keys.** Agents call your provider on your own credentials.
  Switch model or provider without changing anything you have built, and use an
  endpoint inside your own network if you prefer.
- **Your database, per workspace.** Documents, embeddings and retrieval can run
  on your own PostgreSQL rather than ours, with your own embedding model
  (OpenAI, Azure OpenAI, Gemini, Voyage, Cohere or a custom one). It is a setting
  in the workspace, not a different edition of the product. A model you bring
  for embedding or for reading scanned pages always runs on your own key.
- **Your graph, in that same database.** Context Graph knowledge is stored in
  your PostgreSQL alongside the documents. It needs nothing beyond what search
  already needs and permission to create tables, and it is on
  as soon as you choose the model that reads relationships out of your
  documents. There is no separate graph database.
- **Your reranker.** A workspace on its own database can add a rerank model
  (Cohere, Voyage, Jina, or any Cohere-compatible endpoint, including a
  self-hosted one) on its own key, with a Test button. It reorders the top
  results before the agent reads them; if it fails, the search still answers.
- **Know what reading costs.** Providers price a scanned page very differently.
  The settings show the estimated cost of reading 1,000 pages on the model you
  chose, and name a cheaper reader when there is one.
- **Your storage.** Files live in promptev-managed storage with a quota, or in
  your own bucket on Amazon S3 (or any S3-compatible store), Google Cloud Storage
  or Azure Blob Storage. Connecting your own moves the existing files across.
- **Your connector apps**, so the consent screen your staff see carries your
  company's name rather than ours.
- **Retention on your terms.** Conversation files are kept for 30, 60, 180 or
  365 days, or for as long as you like on your own bucket.

Put together: a company can run promptev with its own models, its own database,
its own storage and its own connector applications, on its own infrastructure,
reading code it can audit. What remains is the platform work (connectors,
agents, approvals, audit, channels), which is the part worth buying.

**Where it runs.** On promptev's cloud, hosted on Google Cloud in the United
States; inside your own cloud account in whatever region you choose; or on your
own premises. The last two are Enterprise deployments, and the product is the
same in all three. If your data has to stay in a particular jurisdiction, that
is what your own cloud or premises is for.

**Security and compliance.**

- **SOC 2 Type II** for the service promptev runs.
- Data encrypted at rest with **AES-256**.
- **Your data is never used for training.**
- A data processing agreement and a service level agreement are available, and
  sub-processors are published.
- Live service status at **status.promptev.ai**.

A deployment in **your own cloud account or on your own premises** is your
control environment rather than ours, so our report does not extend to it: the
infrastructure, access and monitoring around it are yours. promptev can support
that audit as part of an Enterprise engagement, at additional cost: the evidence
your assessor asks for, the control descriptions for the parts we build, and
help mapping them onto your own framework. Ask us and we will scope it.

**Google API Services.** promptev's use of information received from Google APIs
adheres to the Google API Services User Data Policy, including the Limited Use
requirements.

---

## Pricing

promptev is pay as you go. There are no seats and no plans, and every feature is
in every workspace.

- **Start free.** A new workspace receives 1,000 free credits once, as a 30-day
  trial that starts at sign-up. That is enough to connect a source, ingest a
  real document and hold a genuine conversation with an agent. No card is
  required. Free credits that are not used in 30 days expire. Credits you buy
  do not expire.
- **Buy credits when you need them.** Credits are **$0.005 each**, with a **$5
  minimum**, so the smallest purchase is 1,000 credits. The rate is shown before
  you buy, with receipts and a payments ledger for every purchase.
- **Auto top-up** can keep a busy workspace running without anyone watching the
  balance, and low-credit notices go out at 80%, 90% and 100% of the last
  top-up.
- **Model costs are yours**, billed by your provider on your own keys, so the
  usage that costs the most is never marked up by us.
- **Enterprise** is an annual licence for a **deployment in your own cloud
  account (any region) or on your own premises**, with onboarding and support.
  It buys a place to run and people to call, not features: single sign-on,
  audit, approvals and the rest are in the product for every workspace,
  including the free one. We size it to your estate rather than to a seat
  count. Compliance support for a deployment you run (evidence, control
  descriptions and help mapping them onto your framework) is available at
  additional cost. **Talk to us: team@promptev.ai.**

**What uses a credit.**

| Activity | Credits |
|---|---|
| A chat turn with an agent | 1 |
| A tool call | 1 |
| A call from a connected app (workspace MCP) | 1 per tool call |
| A triggered run | 1 |
| An API call | 1 |
| Knowledge search in a turn | +1 (5 when the Context Graph search ran) |
| Code execution | +1 |

**Reading documents in.**

| What is ingested | Credits |
|---|---|
| A PDF or Word page, a slide, or an image | 1 each |
| Spreadsheets and other files | 1 per MB (minimum 1) |
| A voice note | 2 |
| Context Graph extraction | 1 per 8 chunks, plus 1 per topic cluster |
| Embedding your content | free |

**Workspaces on their own database or models** pay the same rates as everyone
else.

**From a connected app.** Every tool call an app makes through the workspace
MCP (Claude, ChatGPT, Cursor and the others) costs 1 credit, whether it builds
(listing, creating, updating, publishing) or uses what you built. A call that
searches knowledge, runs an agent or reads a document in adds that work's own
cost, as in the tables above. A call that is refused costs nothing. Working
with Ori in the console is not charged per call, and sending feedback to
promptev is never charged.

The balance is checked before a turn starts and before an action runs, so work
is not started on an empty balance. Auto top-up is the way to keep a busy
workspace from pausing.

A realistic evaluation (ingesting a fifty-page document and asking thirty
grounded questions with a few tool calls) costs on the order of 150 credits, so
the free grant is room to work rather than a demonstration allowance.

---

## Common questions

**What is a context engine?**
The part of an AI system that turns documents, spreadsheets, scans and messages
into knowledge an agent can search, and that decides what the model is allowed to
see for each request. promptev's is permission-aware: the identity of the person
asking is part of the search, so material they cannot open is never retrieved.

**How is this different from enterprise search?**
Search finds documents. promptev answers questions and takes actions under
approval rules, limited to each person's permissions, and runs where you decide.

**How is this different from a suite copilot?**
A copilot is excellent inside the suite that made it. promptev spans Google,
Microsoft, Atlassian, Slack, Dropbox and your own systems, and answers in Slack,
WhatsApp, your website, your phone and your code as well as in the App itself.

**Is any of it open source?**
No. The Context Engine, the part that decides what the AI is allowed to see, is
hosted by promptev. Developers use it through promptev's SDKs and API: put
documents in and search them, with the same permissions as the App.

    pip install promptev            # Python 3.8+
    npm install @promptev/client    # JavaScript / TypeScript

A project API key reads and writes only its own project. The same knowledge
tool is also on every project's MCP server.

**How is this different from a developer framework?**
A framework gives engineers parts to assemble. promptev is the assembled
platform: connectors, permission-aware retrieval, agents, approvals and audit.
Developers can still drive it through the API, SDKs and MCP.

**Do you train on our data?**
No. Your content is used to answer your questions and nothing else.

**Can we use our own models?**
Yes, and it is the normal arrangement. Bring keys for the providers you already
use: OpenAI, Anthropic, Google Gemini, DeepSeek, 34 ready-made providers
(including Azure OpenAI, Google Vertex AI, Amazon Bedrock and Cloudflare), or
any compatible endpoint inside your network.

**Do we need a model key to try Ori?**
No. Ori runs on promptev's own model at no extra charge at launch. The agents
you build with it run on your keys.

**Can we build agents from Claude or ChatGPT?**
Yes. Add the workspace MCP to Claude, Claude Code, ChatGPT, Cursor, GitHub
Copilot, Windsurf, Gemini or another MCP client, sign in with your promptev
account, and build with your own role and permissions. It is available to
builders in every workspace unless an admin has turned off "Allow apps to
connect".

**Do you support SAML and SCIM?**
Yes, in every workspace. Sign-in works over OpenID Connect or SAML 2.0, people
and groups can be provisioned with SCIM 2.0, and company domains proven by a
DNS record send people straight to your identity provider.

**Do we need a separate graph database?**
No. Context Graph knowledge is stored in PostgreSQL with everything else, on
promptev's managed store or in your own database.

**Can we run agents on Azure, Vertex AI or Bedrock?**
Yes. Azure OpenAI, Google Vertex AI (Gemini and Claude), Amazon Bedrock
(Claude) and Cloudflare Workers AI and AI Gateway are ready-made providers.

**Can our documents and embeddings live in our own database?**
Yes. A workspace can point documents, embeddings and retrieval at a PostgreSQL
database you own, with your own embedding model. This is a setting, not a
different edition.

**What exactly can we bring ourselves?**
Models and keys, the database that holds documents, embeddings and the graph,
the embedding model that goes with it, a reranker, file storage, and your own
connector applications. Each is independent, so you can bring one, several, or all of
them.

**Where is our data hosted?**
On promptev's cloud, on Google Cloud in the United States. With Enterprise, in
your own cloud account in any region, or on your own premises.

**What languages does it work in?**
Content and questions in many languages, including asking in one language about
documents written in another.

**How long does it take to see something real?**
Connect a source, wait for it to be read, and ask a question. An afternoon is a
realistic first result, not a quarter.

**What happens when someone leaves, or their access changes?**
Answers follow current permissions. Losing access to a document means losing it
in promptev too, and disabling a member removes their access at once.

**Can an agent do something we did not intend?**
Only if you allow it. Actions are the tools you attach, each with its own
approval rule, and everything an agent does is in the audit trail.

**Do you charge per user?**
No. Adding people is free; you pay for the work agents do.

**Is there a free trial?**
Yes. A new workspace starts with 1,000 free credits for a 30-day trial, and no
card. Free credits that are not used in 30 days expire.

---

## Who it is for

**Best fit.** Companies whose knowledge is spread across several systems, where
different people are entitled to see different things, and where the answer to
"where can this run and who can see what" matters: regulated industries,
professional services, healthcare, finance, the public sector, and any company
with contractors and staff working side by side.

**Roles who buy it.** Operations and IT leaders who need control, department
heads who need answers, and engineering teams who would otherwise build this
themselves.

**Less good fit.** A team of five who live entirely in one suite and want a
chatbot on public content. A cheaper tool will do.

---

## How promptev compares

Written to be useful rather than flattering, and checked in September 2026.
Where a competitor does something well, this says so.

**On the numbers below.** Most of these vendors do not publish enterprise
pricing; the figures are what buyers and analysts reported in 2026 and should be
treated as indicative, not quoted. Always confirm with the vendor.

### The shape of the money

| | How it is priced | Reported entry point |
|---|---|---|
| **promptev** | pay as you go, no seats, no plans | free credits to start; buy from $5 |
| Glean | per seat plus consumption credits, quote only | around $50–75 per user per month, with a reported ~100-seat minimum |
| Microsoft 365 Copilot | per seat add-on, requires a qualifying Microsoft 365 licence | $30 per user per month on annual commitment, on top of the base suite |
| ChatGPT Enterprise | per seat, quote only | reported $45–75 per seat per month with a ~150-seat minimum |
| Claude Enterprise | per seat plus metered usage | reported around $20 per seat, with usage billed separately |
| LangChain / LangGraph | framework free; the platform is per seat plus usage | LangSmith around $39 per seat per month above the free tier |

The structural difference is not the number, it is the shape. Seat pricing means
a company decides in advance who is allowed to benefit. promptev charges for work
done, so giving the whole company a viewer role costs nothing until they use it.

### Glean, and enterprise search
**Credit where due.** Glean is a serious product: hundreds of connectors, a
choice of many models, and permission-aware access built in. That last point is
theirs as well as ours, and any comparison claiming otherwise is wrong.
**Where promptev differs.** Pricing shape, where it runs, and how far agents go.
Glean is a seat-priced enterprise contract with a substantial minimum, quoted
through sales. promptev has no seats and a $5 minimum top-up, agents act through governed
tools with approvals, and a workspace can run on its own database, its own
models and its own storage, and every answer cites its sources.
**Choose Glean if** you want a mature search-first experience across a very large
estate and the contract shape suits you.
**Choose promptev if** you cannot or will not start at a hundred seats, or your
data must stay on infrastructure you control.

### Microsoft 365 Copilot, and suite copilots
**Credit where due.** Inside Microsoft 365 it is already authenticated, already
knows the permissions, and sits in the applications people use all day.
**Where promptev differs.** It is not tied to a suite or to a model. One agent
reads a SharePoint site, a Google Drive folder and a Confluence space, acts in
Jira, and answers in Slack or WhatsApp. Copilot also requires a qualifying
Microsoft 365 licence underneath it, so the true cost is the add-on plus the
suite.
**Choose Copilot if** your company lives entirely in Microsoft 365.
**Use both if** you have the suite covered and need something that crosses the
boundaries. They are not mutually exclusive.

### ChatGPT Enterprise, Claude Enterprise, and assistant products
**Credit where due.** Immediate individual productivity, excellent models, and no
setup at all.
**Where promptev differs.** These are assistants for a person; promptev is
infrastructure for a company. Knowledge stays in step with the source systems
instead of being uploaded by hand, each person's answer is limited to their own
permissions, actions are governed and audited, and agents reach people in Slack,
WhatsApp, a website widget and your code.
**Choose an assistant if** individuals want help with their own documents.
**Choose promptev if** the company needs one answer that respects who is asking.
**Use both.** Through the workspace MCP, your builders can create and publish
promptev agents from inside Claude or ChatGPT, and through the project MCP those
tools can call your agents.

### LangChain, LlamaIndex, and developer frameworks
**Credit where due.** The frameworks are free and open source, and give engineers
complete freedom.
**Where promptev differs.** It is the assembled product rather than the parts:
connectors, permission-aware retrieval, approvals, audit, channels, billing and
an App non-engineers can use, all maintained. Note also that the surrounding
commercial platform is itself seat-priced above its free tier, so "framework" and
"free" are not the same sentence in production.
**Choose a framework if** the agent behaviour is your product.
**Choose promptev if** the agent is a tool your company uses, and developers keep
the API, the SDKs and MCP when they want to go deeper.

### Workflow automation (Zapier, n8n, Power Automate)
**Credit where due.** Deterministic steps between systems, cheaply and reliably,
and far easier to reason about than an agent.
**Where promptev differs.** It reasons over your knowledge before acting, and
asks a human when an action deserves it. A workflow follows a path you drew; an
agent decides what the situation needs.
**Use both.** The routine plumbing is automation; the judgement is an agent,
which a workflow can call through its callable URL.

### Building it yourself
**Credit where due.** It is genuinely achievable, and it fits your company
exactly.
**What it costs.** The demonstration takes a fortnight. What follows is
connectors and their token refreshes, permission-aware retrieval, re-indexing
when files change, scanned documents, approvals, audit, per-person access,
channels, billing, and an App other people can use, then maintaining all of it
as each provider changes its API.
**Choose to build if** this is your product.
**Choose promptev if** it is not. The engine, the part that is hardest to get
right, is ready, and your own code can use it through the SDKs and the API.

---

## Objections, answered honestly

**"We already have a copilot."** Keep it. promptev covers the systems it does not
reach, and the permission and approval controls it does not offer.

**"We could build this."** You could. Teams that have usually rebuild retrieval,
permissions, connectors, approvals and audit, and then maintain them. The
question is whether that is your product.

**"Our data cannot leave our network."** Then run promptev in your cloud or on
your premises, with your own models. That is a supported deployment, not an
exception.

**"How do we know it will not leak?"** Permissions are part of retrieval rather
than a filter applied afterwards, so material a person cannot open is never
fetched for them. Every answer cites its sources, so you can check each one.

**"Our people will not learn another tool."** They do not have to. Agents answer
in Slack, WhatsApp, on the phone and on your website, and builders can work from
Claude, ChatGPT or Cursor through the workspace MCP, or just ask Ori.

**"What if we stop using it?"** Your documents stay where they always were. Your
model keys are yours. Nothing about your data is promptev's to keep.

---

## Using promptev: step by step

The App is organised in two layers. A **workspace** is your company: members
and roles, billing, storage, audit, connector settings and single sign-on live
there. A **project** is a body of work inside it, with its own agents,
orchestrations, knowledge, tools, connectors, masking and API keys, so a finance
project and a support project never see each other's material.

At any step, you can open **Ori** in the sidebar and ask it to do the step with
you.

### Create a workspace
Sign in and create one. A brand-new workspace receives 1,000 free credits for a
30-day trial so you can evaluate properly. You are its owner.

### Create your first project
A new workspace has no project yet, and most screens need one. In the left
sidebar, under **Projects**, choose **Create your first project** (or the plus
beside the heading), name it, and you land inside it. Create as many as you need;
a project is the boundary that keeps work separate.

### Invite your team
**Members** at the workspace level. Invite by e-mail address and choose a role:
owner, admin, editor or viewer (see **How a workspace is organised**). Invited
people receive an e-mail. Adding people is free. Projects have their own roles
too, so someone can build in one project and only chat in another.

### Connect a source of knowledge
Inside a project, open **Connectors**, choose the service, and connect it. You
authorise it once with your own account, then pick exactly what promptev should
read (a specific Drive folder, a Confluence space, a Jira project) rather than
everything you can see.

To use promptev's connector applications, an admin switches the connector to
promptev-managed in **Settings → Connectors**. To use your own registered
application so the consent screen carries your company's name, set up its
credentials there instead.

### Add knowledge directly
**Knowledge** inside a project. Upload documents (up to 25 MB per file and 20
files per upload), or add the files you picked from a connected source. You can
watch each file being read, and re-read one on demand if the source changed.
Choose the audience for uploaded documents. Sensitive values can be masked
before the model reads them; see **Masking** under **Governance and control**.

### Add a model
**AI providers** at the workspace level. Add a key for the provider you already
use, pick one of the 34 ready-made providers (the cloud platforms ask for
their own details, such as a resource, a region or a service account), or add
a custom compatible endpoint. Model calls go straight to that provider on your credentials.

### Create an agent
**Agents** inside a project, then **New agent**. Say what it should do in plain
words, attach the knowledge it may use, choose the model, choose whether it
answers strictly from its knowledge or flexibly, and add tools. Test it
in the built-in chat before anyone else sees it, then publish a version. You can
roll back to an earlier version at any time.

### Give it tools, and decide what it may do alone
In the agent's **Tools** step, attach tools from the connectors you have
authorised, from your own HTTP and database tools, or from an MCP server you
point at. Each tool carries an approval rule (Inherit, None, Ask once or Always
ask), described in **Approvals** above. Registered tools can also use "Ask if…"
conditions. Pending requests are on the **Approvals** page.

### Put the agent where your team is
- **The App**: people with access find it in the Agent
  library.
- **Slack or WhatsApp**: connect the channel in **Settings → Channels**, then
  attach the agent to it. One agent answers per channel.
- **Your website**: an embed you add with one script tag, restricted to the
  sites you name.
- **Your code**: create a project key under **API** inside the project, or use
  the agent's callable URL.
- **AI tools**: connect an MCP client to the project MCP with a project key.

### Compose several agents
**Orchestrations** inside a project. Choose a lead agent and the team of agents
it directs. Start a run by hand through its intake form, on a schedule, through
its callable URL, or from another agent. Runs can pause for a reviewer's
sign-off and resume where they left off.

### Let builders work from their own AI tools
Builders add the workspace MCP (`https://api.promptev.ai/mcp`) to Claude,
ChatGPT, Cursor or another MCP client and sign in. This is allowed in every
workspace unless an admin turns off **Allow apps to connect** in Settings.
Each person sees and signs out their apps under **Profile → Where you're
signed in**.

### Watch what is happening
- **Home**: the usage dashboard, with model spend, savings and waits.
- **Audit**: every run, approval and settings change, and who did it.
- **Approvals**: what is waiting for a human.
- **Artifacts**: every file agents have made, and what has been shared with you.
- **Notifications**: approvals, held runs, connectors needing attention and
  low credit, in the App and by e-mail.

### Buy credits
**Billing** at the workspace level. Buy credits from $5, with receipts and a
payments ledger. Auto top-up keeps a busy workspace running without anyone
watching the balance.

### Set up single sign-on
In the workspace settings, open the single sign-on panel. Register an
application with your identity provider over OpenID Connect or SAML 2.0, using
the addresses shown there, and enter its details. Or create a **setup link**
and send it to your IT admin, who can do all of it without a promptev account.
Use **Test connection** to see what your provider sends before anyone relies on
it. Add your domain under **Company domains** and publish the DNS record shown;
once it is proven, people on that domain are sent to your provider from the
sign-in page, and can join automatically with the default role you choose. For
provisioning, create a SCIM token and give it to your identity provider. SSO
can be required for everyone, or everyone except viewers.

### See where you are signed in
**Profile → Where you're signed in** lists your browsers, devices and connected
AI apps. Sign out any one of them, or all the others at once.

### Point knowledge at your own database
**Settings → Context engine**. Documents, embeddings and retrieval for this
workspace run either on promptev's managed store or on your own PostgreSQL, and
the panel says which is in use. With your own database you also choose your
embedding model (on your own key), the model that reads scanned pages, the
model that builds Context Graph knowledge (the graph is stored in that same
database), and optionally a reranker. The panel shows what reading pages will
cost on the model you picked. **Test connection** checks the database address
you typed before anything is saved.

When you connect your own database, the documents the workspace already has
move into it on their own. If your embedding model is the same as before, they
are copied as they are; if it is different, each one is embedded again with
your model. Saving tells you the migration is in progress, the Knowledge page
shows how far it has got, and owners and admins are notified when it is done.
Answers may miss documents until it finishes. If some documents could not be
moved, the page says which and offers a retry. The workspace's tools, their
approvals and their call records move to your database too, so everything the
context engine holds for you is in one place; tool credentials stay encrypted
with promptev's key. The **Save** button stays in view at the bottom of the
page while you work through the sections.

### Choose where files live
**Storage** at the workspace level. promptev-managed storage has a quota, and
you choose how long conversation files are kept. Connect your own S3,
S3-compatible, Google Cloud Storage or Azure Blob bucket instead if you would
rather hold the files yourself; existing files are moved across.

---

## Getting started

1. Create a workspace and a project.
2. Connect one source you already use.
3. Add a model key.
4. Create an agent (or ask Ori to), attach the knowledge, and ask it something
   you know the answer to.
5. Put it where your team is: the Agent library, Slack, WhatsApp, your website
   or the API.

1,000 free credits are granted on sign-up for a 30-day trial, and no card is
needed to evaluate.

## Contact

Website: https://promptev.ai
Sales and support: team@promptev.ai
Service status: https://status.promptev.ai