Pyak
Pyak is a visual builder for the AI agents that answer your customers. You design each conversation as a flow, wire it to your own data, and deploy the same agent to chat, an API, and your phone lines. The work that arrives the same way every day (order status, appointment changes, account lookups, support requests) is handled by an agent you can see, test, and change without writing code.
Visit pyak.net
Build the conversation, or describe it
The heart of Pyak is a visual flow editor. You lay out the conversation as a connected diagram: what the agent does at each step, how it branches on the customer's answer, when it looks something up, and when it hands off to a person. Every node type is explicit (gateway, agent, guardrail, database, response), so the logic stays in view. Prefer to describe it? The built-in Builder Chat turns plain-language instructions into a working flow, then edits that flow the same way as you refine it.
Run your agent before it ships
The Execute view lets you talk to your agent in real time while you are still in the editor. The right panel shows its full context (instructions, tools, and configuration) as each node runs, so you confirm the behavior before anyone else sees it. It is the same engine that serves production traffic, so what you test is what ships.
Automated test suites
The test builder reads your flow and writes test scenarios against it: edge cases, adversarial inputs, boundary conditions. Run them after any change and regressions surface before your customers find them. Every case is visible and editable, so you can keep the generated ones or write your own. Each flow version is saved on its own, so you always know which change moved a result.
Full execution traces
Every conversation leaves a trace: the path it took through the flow, what the agent received at each node, and what it sent back. Traces are kept per session and per run, so looking into one interaction means opening that run and reading the real data at every step. You never have to guess what the agent saw.
One agent, every channel
Publish a flow and it becomes a live endpoint with its own key, callable from a CRM, a mobile app, an internal tool, or anything that speaks HTTP. The same flow can answer a phone call: Pyak connects it over SIP, handles the turn-taking, and lets the agent look things up mid-call, then transfer or hang up on its own logic. Chat and voice run on the same nodes and the same session state. Only the entry point changes.
Grounded in your data
Agents answer from your data, not guesses. Table databases give you a typed, spreadsheet-style store your team edits directly and your flows read at runtime. Knowledge bases hold your documents as searchable vectors, so an agent can ground its answers in your own policies, catalog, or documentation. What the agent reads stays in step with what your operations team maintains.
More in the platform
Guardrails as nodes
AI checks on inputs and outputs that you can see and edit in the flow, not hidden config.
Custom plugins
Connect your own systems with sandboxed Python actions, written with AI help.
Role-based access
Organizations, roles, and per-resource permissions for teams and clients.
Encrypted secrets
API keys and credentials encrypted at rest, supplied at runtime, never returned.
Versioned flows
Every published version is immutable, so live edits never rewrite past behavior.
Browser automation
Agents can drive a real browser to fetch and normalize external data.
Deployed in finance, healthcare, e-commerce, legal, and logistics. Enterprise tier available for organizations with strict data residency requirements.
See Pyak at pyak.net →