skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
pipefy/ai-toolkit802 installs

pipefy-process-intelligence

Use this skill when the user wants to analyze an existing pipe for improvement opportunities — automation gaps, manual bottlenecks, missing AI agents, field conditions, or adjacent processes. Acts as a process analyst: investigates, diagnoses, and improves the pipe in progressive rounds — each round delivers visible results.

How do I install this agent skill?

npx skills add https://github.com/pipefy/ai-toolkit --skill pipefy-process-intelligence
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    This skill is generally safe and intended for process optimization within the Pipefy platform. It has a potential surface for indirect prompt injection because it analyzes user-controlled card data and possesses the capability to modify process configurations and automations.

  • Socketpass

    No alerts

  • Snykfail

    Risk: CRITICAL · 2 issues

What does this agent skill do?

Process Intelligence

Read the MCP reference or CLI reference for the surface you are using. Load only the relevant reference.

Analyze existing pipes for improvement opportunities and implement them progressively. Investigate immediately. Diagnose with data. Improve progressively.


When to use

The user asks to analyze or improve an existing process:

  • "Analyze my pipe"
  • "How can I improve this process?"
  • "Is this pipe optimized?"
  • "Where are the bottlenecks?"

Not for: designing a new process from scratch → use pipefy-process-design. Justifying a change with numbers, without implementing it → use pipefy-process-impact.


Prerequisites

  • Pipe ID or name is known (or searchable via search_pipes).
  • Read access to the pipe's cards and phase data.

Steps — investigation (Round 1)

  1. Get pipe structure:

    Operation: get_pipe pipe_id=<id>

    Capture: phases, field count per phase, automation count.

  2. Sample recent cards (last 30–50):

    Operation: get_records pipe_id=<id> first=50 include_fields=true order_by=[{"attribute": "CREATED_AT", "direction": "DESC"}]

    Keep the sort: without it the oldest cards come first, and the first page is no sample of recent work. Look for: cards piling up in early phases, phases with 0 cards, fields left empty. get_records selects createdAt, updatedAt and finishedAt but no phase timestamps; the timed card read under the diagnosis framework does.

  3. Check automations:

    Operation: get_automations pipe_id=<id>

    Look for: phases with no automations (manual handoffs), repeated manual steps.

  4. Check AI configuration:

    Operation: get_ai_agents repo_uuid=<PIPE_UUID>

    For each active agent (disabledAt is null), read its behaviors to see which phases it already acts on:

    Operation: get_ai_agent with the agent's UUID

    Look for: no AI agents despite manual categorization or triage patterns, and hops an active behavior already covers (do not report those as manual).


Diagnosis framework

Time-based signals need phase dates that get_pipe and get_records do not return. Per-card signals (stuck in a phase for more than 7 days, no update in weeks) come from a timed card read: one execute_graphql query on the pipe's cards, with variables {"pipeId": "<id>"}:

query TimedCards($pipeId: ID!, $first: Int = 25, $after: String) {
  cards(pipe_id: $pipeId, first: $first, after: $after) {
    pageInfo { hasNextPage endCursor }
    edges { node {
      id done createdAt finished_at started_current_phase_at current_phase_age updated_at
      current_phase { name }
      phases_history { phase { name } firstTimeIn lastTimeOut duration }
    } }
  }
}

duration is seconds per phase; lastTimeOut is null on the phase the card is in. The cards query returns the oldest cards first and takes no sort, so the first pages describe the pipe's oldest cards, not recent work: page to the end, or use a pipe report export for recent numbers. It is a read with no confirmation, 25 cards per page (up to 50), so say how many cards the numbers come from. Pass "after": <pageInfo.endCursor> in variables for the next page.

Whole-pipe signals (a phase with no card in 90 days, cards leaving a phase per week) need every card, because the cards query returns the oldest cards first and takes no date filter or sort, so one page proves nothing about the cards it left out. Page the timed read until hasNextPage is false, or use a pipe report export (pipefy-reports) with start_at_phase_<n> and end_at_phase_<n> (<n> is a report index, not the phase id); the export needs an existing report (get_pipe_reports), and creating one with create_pipe_report is a write, so ask first. Without full coverage, say the signal was not checked; do not call a phase dead from a sample, and do not infer time from cards_count.

SignalOpportunity
Cards stuck in a phase for >7 daysAdd due date field + overdue automation
Phase transitions always done by same personAutomate the transition condition
Fields never filled in certain phasesRemove or make optional
Same comment posted repeatedlyA native rule only when a field test and an available comment action cover the step (get_automation_actions). When judgment decides the comment and an agent action covers it, recommend an AI agent on a card event. Otherwise, report the limitation or keep the comment manual. Offer a field update only if it carries the same signal and the user accepts that change.
No automation between intake and first actionAdd "notify assignee" automation on card creation
Large field count on start formMove optional fields to later phases
Phases with 0 cards over 90 days (whole pipe, not a sample)Merge into a neighboring phase, or replace the hop with an automation or AI agent. Do not treat an empty phase as a reason to delete the pipe.

Choose the Pipefy part for each opportunity with the selection table and the rules under it in pipefy-process-design ("Choose the Pipefy part for each step"). Repetition alone does not prove a need for AI: a native rule covers a repeated step with a fixed test. An AI agent can act on a card event, such as a new card or a move to a phase, not only in a conversation. When the table points at an AI automation or an AI agent, recommend it. Give the reason, the test, and the effect of a wrong output. A confirmed AI line in the specification is the user's yes. Without that yes or a request for AI, ask before creation. Do not ask again after a yes. "No AI" removes AI from the recommendations and the build, even after an earlier yes.


Steps — improvement (Round 2+)

Each round focuses on 1–2 improvements; report results before proceeding.

Example: automate a repeated manual step

  1. Identify the manual step and its trigger.

  2. Call get_automation_events and get_automation_actions for the pipe; select a supported event and action.

  3. Create the automation in the state from "Start state" in pipefy-automations. When the pipe has cards that the rule can match, create the automation inactive, then activate it in step 4 unless another off case applies. This example shows that inactive case:

    Operation: create_automation pipe_id=<id> name="Automate manual step" trigger_id=<EVENT_ID> action_id=<ACTION_ID> active=false

  4. Read the rule and compare it with the request. If it matches and no other off case applies, activate it in this build without another question. Report the actual event and action. If either is unavailable, report the limitation instead of an invented ID.

Example: add a field condition

  1. Identify a field that should only show when another field has a specific value.

  2. Read the phase's current rules with get_field_conditions(phase_id), so the new condition does not repeat or contradict one.

  3. Read the field-condition input schema, then create the condition with its required name, condition dict, and actions list:

    Operation: create_field_condition phase_id=<PHASE_ID> name="Show follow-up" condition=<CONDITION_DICT> actions=<ACTION_DICTS>


Output format per round

## Analysis — [Pipe Name]

### Findings
- [Finding 1]: [evidence from tool calls]
- [Finding 2]: ...

### Implemented this round
- [Change 1]: [tool called + result]

### Impact
[One line: minimum step done or proposed, time it returns to the team (formula with the missing numbers named), and the extra lift of the next step, or "next step does not close". Lead time only if this round already has dates.]

### Next round (if approved)
- [Opportunity]: [proposed action]

Keep Impact to one line. Do not invent volume, hourly cost, or lead time; name every missing number and ask for all of them in one question. For a fuller justification, read pipefy-process-impact. Do not recommend deleting a pipe.


Success criteria

  • Each round produces a concrete visible change (new automation, field condition, phase cleanup).
  • The affected phase moves more cards: compare cards leaving it per week (lastTimeOut in the timed card read, or end_at_phase_<n> in a pipe report export) before and after the change, or ask the user.
  • No improvement causes a regression (verify with get_pipe and get_records after each round).

Failure modes

  • get_records returns no cards: the pipe may have no cards yet. Analyze structure only, and recommend standing up intake (start form, portal, or an automation that creates cards) rather than removing the pipe.
  • create_automation fails with unknown event: use get_automation_events to list valid triggers.
  • User pushes back on automation: explain what the automation does in plain language before creating.

See also

  • pipefy-automations — detailed automation creation guide.
  • pipefy-ai-agents: AI agents that act on a card event or in a conversation.
  • pipefy-observability — check credit and execution data to quantify improvement impact.
  • pipefy-process-impact for a fuller justification; this skill only emits the Impact line per round.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/pipefy/ai-toolkit/pipefy-process-intelligence">View pipefy-process-intelligence on skillZs</a>