Welcome to Peki
Peki is where you build AI agents that talk to your customers, do real work for them and hand them to your team when a person is needed. You describe what you want, the Copilot builds and tests the agent with you, and you publish it to your website chat, Telegram or your own app.
These docs cover every part of Peki: what each feature does, every setting and limit, and what to do when something goes wrong.
Who Peki is for
- Businesses that want an agent on their website or Telegram: an online store answering "where is my order?", a dental clinic taking appointment requests, a SaaS support desk answering from its help center.
- Creators and small teams who want an assistant that knows their content, collects leads and sends them alerts, without writing code.
- Developers who want to put an agent behind their own app, call their own APIs from it, write small TypeScript Functions, or start automations from webhooks.
You don't need to know how AI models work. The Copilot asks plain questions and does the setup. If you do know, every part is open for you to edit by hand.
What an agent can do
An agent answers customers in their language, around the clock, using what you gave it. Depending on how you build it, it can:
- Answer from your documents and web pages (Knowledge).
- Look things up or change things in your systems through APIs (Tools and Functions).
- Follow a step-by-step how-to for one kind of question (Skills).
- Save what customers tell it into your own tables, like leads, appointments or orders (Records).
- Wait for your team to approve an important action before it happens (Approvals).
- Bring in a person when the customer asks for one, or when your rules say so (Handoff).
- Run on its own on a schedule, or when another system calls it, and send you a Telegram message (Automations).
- Ask other agents of your workspace for help and write one answer (Agent teams).
- Read photos and documents customers send (Files).
A tour of the building blocks
Every agent is made of the same parts. Each has its own page in the sidebar.
| Building block | What it is | Read more |
|---|---|---|
| Copilot | An AI assistant inside Peki that builds and changes the agent with you. It edits the draft, tests every part with real calls and stops for your approval before anything with real effects. | Copilot overview |
| Document | A plain-words description of the agent: business, job, what it can do, limits, handoff, tone and channels. The Copilot keeps it current. | The Agent document |
| Instructions | Ordered prompt blocks the agent always follows: who it is, tone, language, hard rules. A block can apply only on one channel, during business hours, or for tagged customers. | Instructions |
| Tools | Actions the agent can take during a conversation. An HTTP tool is one call to an API. | Tools |
| Functions | Small TypeScript programs that run in a locked sandbox: several API calls, calculations, reshaping data. | Functions |
| Skills | How-to steps the agent loads only when a matching question comes up, so its always-on instructions stay short. | Skills |
| Knowledge | Documents, web pages and text the agent searches before it answers. | Knowledge |
| Variables and Secrets | Reusable values like your business name, and encrypted API keys your tools use. | Variables and secrets |
| Model and behavior | The model and fallback model, memory, sessions, the fallback reply and web search. | Model and behavior |
| Guardrails | Checks on every message and reply: prompt injection, off-topic questions, instruction leaks, offensive messages, and personal-data masking. | Guardrails and privacy |
| Records | Your own tables of data the agent collects and keeps. | Records |
| Approvals | A queue where your team checks an action before it runs. | Approvals |
| Automations | Jobs the agent runs on its own: on a schedule, from a webhook, or on a Peki event. | Automations |
| Agent teams | Other agents this agent can ask while it answers. | Agent teams |
| Channels | Where customers reach the agent: website chat, Telegram and the Sessions API. | Channels overview |
| Inbox | Every conversation in one place. Your team watches, takes over and replies. | Inbox |
| Analytics | How well the agent answers and what it brings in. | Analytics |
Draft and published versions
Every agent has a draft that you and the Copilot edit, and published versions that customers talk to. Testing uses the draft. Publishing turns the draft into the next live version on every connected channel at once. You can restore any earlier version into the draft. See Publishing and versions.
Some settings apply right away without publishing: channel settings, Knowledge sources, and workspace variables. Everything else in the agent waits for Publish.
How a customer conversation flows
When a customer writes, Peki prepares the agent, hides personal data from the model, lets the agent use its tools, checks the reply and records everything. You can watch each reply happen in the Inbox.
A few things to know about this flow:
- Customers always talk to the published version. Changes you make in the draft don't reach them until you publish.
- Personal data stays out of the model. Names, phone numbers, emails, ID and card numbers reach the model only as placeholders. Your tools still receive the real values.
- The model never sees your keys. Keys are added to a request only on the way out, and only for the sites you allowed.
- A customer never gets an empty message. If every model fails, the agent sends your fallback reply, if you set one.
- Each reply has a trace. In the Inbox, Why? shows which prompt blocks, skills, tools and Knowledge the reply used, with tokens and time.
Where to start
- New to Peki? Follow the Quickstart: sign in, build your first agent with the Copilot, test it, publish it and put the chat on your site.
- Want the vocabulary first? Read Key concepts.
- Setting up your team? See Accounts and workspaces and Members and roles.
- Building with code? Start at the API overview.
- Hit a problem? Check Troubleshooting, the FAQ and the Limits.