Build agents as flows you can see.
Pyak is a visual workflow builder for AI agents: connect nodes for language models, branching logic, databases, and plugin actions, then run the result over an API, a chat session, or a phone call.
Extend it with plugins
A plugin is Python code plus a manifest. Install one from the store, or write your own and let the built-in AI assistant edit the two files it touches.
How it's put together
The engine behind every flow, whether it's answering a chat message or a phone call.
Visual flow builder
Design agents as a graph of nodes: language model calls, branching, loops, database reads and writes, plugin actions, and guardrails, all on one canvas. Or describe what you want and let the Builder Chat agent assemble the graph for you, node by node, and edit it the same way later.
Three ways to trigger
The same flow answers an HTTP request, holds a WebSocket session, or takes an inbound phone call. Pick the gateway node your use case needs.
Databases you own
Store structured tables, index documents in your own Elasticsearch cluster, or embed knowledge for retrieval, each scoped to your organization.
Plugins in plain Python
Write a plugin as Python code and a manifest, or install one from the store. Flows call its actions directly or hand them to an agent as tools. A built-in plugin assistant can write the change for you from a plain-language request.
Guardrails you can see
Guardrails are flow nodes, not hidden settings. Write the judge prompt, wire it to the step it checks, and see it in the graph.
Tests that simulate conversations
Chain turns together to build a multi-step conversation, then assert on how the agent responds three or four turns in. A Test Builder Agent can read your flow and draft those scenarios for you.
Every agent runs from one flow: the same graph answers an API call, a chat session, or a phone conversation.
One engine, every channel
A flow doesn't care whether the trigger is an API call, a WebSocket session, or a ringing phone. Build it once.
Talk to it however you want
The same published flow answers an HTTP request, holds a WebSocket session, or takes an inbound phone call. Pick the gateway node your use case needs.
Real inbound telephony
Calls land in the same flow engine as any other trigger: barge-in turn detection, DTMF, live transfer, and per-call recording.
State that follows the conversation
A phone call and a chat session with the same agent share the same session and turn model, so a flow can read or update conversation state from either one.
What runs underneath
The pieces every flow is built from, whether it answers a chat message or a phone call.
Design a flow and publish it. All the infrastructure that runs it is already built into the platform, not something your team sets up, scales, or keeps online.
A flow can control a real web browser: open pages, interact with them, and read back the results. Logins and session state carry over between steps in the same run.
Each organization's data stays fully separate. Roles are hierarchical, permissions are fine-grained, and usage against your plan is tracked automatically.
Your keys and credentials are stored encrypted and used only when a flow actually needs them. Access can be revoked at any time, and sign-in and execution are protected against abuse.
Where teams put it to work
Concrete patterns the node types and trigger paths above are built to support.
Route tickets, draft responses, summarize documents, and trigger downstream systems through plugins, all as flows an ops or support team can build without writing code.
Agent nodes with database lookups ground answers in your own documentation, policies, or product catalog. Guardrail nodes enforce whatever policy you write as a prompt.
An agent answers a phone line, holds a multi-turn spoken conversation, looks things up mid-call, and transfers or hangs up based on flow logic.
The organization, tier, and role model is built for reselling agent capacity to separate customers under one deployment, with per-organization data isolation for each tenant.
The browser node keeps a cookie-persistent session alive across a run: log in once, then navigate and scrape across several steps, and write the result to a database.
Chain conversation turns into a test flow and assert on how the agent responds several turns in, before you publish a new flow version.
Built for Developers
Documentation, SDKs, and a REST API to help you call your published agents from your existing stack.
Initialize the Agent
Install our lightweight SDK and start automating in seconds.
npm install @pyak/sdk
// Initialize the agent client
const agent = new PyakAgent{
apiKey: 'pyak_live_...',
workflow: 'customer-support'
});