Workflows

Workflows define how Faundr works in your project. Each one is a script of steps your AI agent follows when a request touches a given topic: "for anything design-related, read design.md, show the plan, build it, audit it and check it on mobile".

Without a workflow, the agent picks its own path on every request. With one, it follows the approach your team agreed on, and you can watch on the canvas which step it's on.

The tabs

They all open on the same canvas. Click a block to see its details in the side panel.

From Faundr

These diagrams come from Faundr itself and are marked Faundr default, so they describe what it really does. Every decision is a diamond (yes and no), steps that run at the same time sit side by side, and each step names the skill or command it uses.

Automatic: Session start, Each request, Before editing, Before a command, After a command, End of response, Background checks, Architecture outside the plan and Session end.

Faundr skills: one per skill (planning, design, security, merge, undo…), with its modes, the points where it asks you something and where it ends. Each one says whether it runs only when you call it in the terminal or whether the agent can also call it on its own, and which part of Faundr calls it (for example, End of response calls the design audit). The short tracking and setup commands live in two diagrams: Work log and Configuration.

You can't edit the steps. What you can do is turn steps off for this project, and the rest explain why they always stay on. In Faundr skills, only optional steps can be turned off (for example, measuring in the browser during the design audit, the subagent review in planning, or coverage in tests). When the skill starts, Faundr tells the agent which ones to skip. Security, proof that it works and questions to you can never be turned off. Each change applies to the whole team starting with the next request (session-start changes apply from the next session). Reset to default turns everything back on.

When a new Faundr version changes a diagram:

• if nobody touched it, it updates on its own;
• if the project turned off a step, you'll see New Faundr version with what changed. Update goes back to the new default with everything on. Keep mine keeps the steps your team chose.

What's in a workflow

Each workflow reaches the agent once per session, so it doesn't repeat.

Trigger: who runs it and when it kicks in

Team workflows, skills and Faundr skills all share the same trigger settings, in the panel next to the canvas:

Who runs it

• You and the agent (default): the agent also calls it on its own when the trigger matches.
• Only you, in the terminal: the agent doesn't call it on its own. If it tries to run the skill, Faundr blocks it. When the trigger matches, the agent just reminds you in one line ("this looks like a job for /x, want to run it?"). A skill that marks itself as "only the person runs it" always stays this way.

When it kicks in (check as many as you like)

On a schedule is a scheduled reminder. Faundr never opens your agent by itself. Once the time passes, the next session opened in the project (by whoever is working) receives the request, just once. If nobody opened a session for days, only the most recent one is delivered, without piling up. The panel shows the next scheduled time and the last one delivered. Changing the time won't fire one that already passed today.

A trigger change applies from the next request, without restarting the session.

The blocks

Each block has its own shape on the canvas, so you can read the flow at a glance:

Build by dragging: the palette on the left has the blocks and the skills linked to the project. Drag one onto the canvas, or click to place it under the selected block (already connected to it). Connect blocks by dragging from one block's handle to another, on any side: top and left are inputs, bottom and right are outputs. Double-click a block's name to edit it in place. Tidy up arranges everything in layers, with branches side by side.

A connection can carry a written condition ("if it's design-related"). The agent only follows it when the condition holds.

The What the agent reads box in the side panel shows the exact text the agent receives, with the steps numbered in order.

Project skills

The Skills tab lists the skills your team already uses in the project, from three sources:

• Project: the ones in the repository's .claude/skills (Claude Code) and .agents/skills (Codex) folders.
• Personal: the ones in each person's own skills folder, on their computer (~/.claude/skills in Claude Code; ~/.agents/skills or ~/.codex/skills in Codex).
• Plugin: the ones from Claude Code and Codex plugins enabled for that folder (the card shows the plugin's name).

Faundr's own skills aren't listed here. They have their own diagrams in the From Faundr tab. The buttons at the top filter by source, and search looks through each skill's name, description, when to use and topics.

Connecting them

Run /faundr:skills in your agent (or click Connect or update, which copies the command). Faundr reads the skills on your computer, and the agent writes two things for each one:

• When to use: one sentence describing the request, like "request to write or improve a page's copy."
• Topics: 2 to 5 words or phrases that should remind the agent of the skill when they show up in a request (e.g. headline, home page copy). With no topics, the skill's name is used.

To update just one, run /faundr:skills <name>. While any skill is missing its "when to use," the tab shows how many, with an Ask the agent to write it button.

Each session re-reads the skills on its own, so a new skill shows up in the dashboard without you doing anything. A skill that's gone from everyone's computer drops off the list. In a skill's details, the dashboard shows how many teammates' computers have it.

Topic reminders

When a request touches one of a skill's topics, Faundr reminds the agent about that skill before it reads the request, even outside a workflow. The reminder includes the skill's name and when to use it, and the agent calls the skill instead of doing the work by hand, when that makes sense.

• Each skill comes up at most once per session, with no more than 2 skills per request.
• If you already typed /name at the start of your request, there's no reminder.
• It all runs on your computer, with no AI and no internet, from a local copy of the list.
• The Matches an enabled skill? step in the Every request diagram (under From Faundr) turns these reminders off for every skill at once.

Besides topics, a skill can kick in at any of the other trigger moments (see above): before editing certain files, at the end of a response, after a commit, on a schedule and so on.

Manual-only skills

Some skills can only be run by a person (the skill's own file says so). They're tagged manual only. When a topic matches, the agent doesn't run the skill. Instead, it reminds you in one line, something like "this looks like a job for /name, want to run it?" On the canvas, these skills get an extra You run /name step in front of them.

You can make any skill work this way: in its details, under Who runs it, choose Only you, in the terminal. If the agent tries to run a skill set like that, Faundr blocks it.

A skill's details

Click a skill to open its canvas, with a side panel:

• What it does (from the skill): the description from the skill's own file.
• When to use and the trigger (who runs it, when it runs, topics and files). Make your changes and click Save.
• Connected to the dashboard: the skill's type (see below).
• Remind the agent about this skill: when it's off, the skill is left out of topic reminders but stays in the canvas palette. Turned-off skills look dimmed in the list.

Only people who can edit the project can change these.

In the canvas palette

Every linked skill shows up in the workflow canvas palette, grouped into Project, Personal, From Faundr and Other plugins, with search by name. Drag one onto the canvas to make it a block in your workflow.

Skills that find problems

In /faundr:skills, the agent also flags the skills whose job is finding problems: security, tests, code quality or app errors. They get a Connected · Security tag (or Quality, Tests, Errors) and start sending their results to the dashboard:

• When one of them runs (the agent calls it or you type /name), Faundr asks the agent at the end of the response to record what it found and what got fixed in the conversation.
• Each problem lands in the right section as if Faundr had found it: Security (S-n), Quality (Q-n), Tests (T-n, missing tests) or Errors (E-n), tagged via /name. It counts toward Launch and Insights like any other finding.
• Each skill only closes its own findings. If it runs again and no longer finds a problem, that finding closes, while findings from Faundr and other skills stay as they are. When it runs on only some files, only the findings in those files close. If it finds nothing at all, its open findings close.
• You can change the type in the skill's details, under Connected to the dashboard: No, it doesn't look for problems or Yes, its findings go to whichever section you pick. A skill the agent hasn't looked at yet shows as Not classified yet.
• Faundr's own skills aren't included, since they already record their own findings.

Who creates and who approves

• You create workflows in the dashboard. New workflow opens the ready-made templates (Study another project, New screen, Fix a bug, Before publishing, Security review) or a blank one.
• The agent proposes them. When it notices a way of working that keeps repeating, or when you ask with /faundr:workflow, it saves a draft. The card shows up with a highlighted border and "Proposed by the agent. Review and approve."

Only Active workflows count. Drafts and disabled workflows don't reach the agent. Approving, editing, disabling and deleting always stay with the team, in the dashboard. The agent never changes a workflow on its own.

Workflows don't run by themselves. They guide the agent in the session you opened.

Follow along live

When the agent follows a workflow, it marks each step and the canvas lights up right away:

Some steps get marked automatically based on what Faundr sees the session do, without the agent having to report it. Calling a step's skill puts it in Running, a command that finishes successfully completes the Action (or Wait) with that command, and opening agents puts the Agents block in progress. Whatever comes before that step along the connections is marked done, and side branches in an "in parallel" block don't change. These show · seen.

An open run with no signal for 15 minutes shows as No updates. Closing your agent automatically ends any runs that session left open.

In the list, the workflow card shows In progress or Waiting for you while a run is open. Inside it, the Runs list keeps the last 20, with who followed it, the request, the progress (3/6) and the computer. Click one to see on the canvas where it stopped. Stop this run ends one that was left open.

Two people on the same workflow

Each person who follows a workflow gets their own run, and one person's progress never marks anyone else's.

• Who's on which step. With two runs open, the top of the canvas shows Now: with each person and their step. Click one to see their canvas. The card in the list shows how many people are following it.
• Waiting for you only appears for the person who owns the run. Everyone else on the team sees Waiting and that person's name.
• Starting a workflow someone else is already following isn't blocked. The agent is told who's following it and on which step, and it checks with you before steps that can't run twice at the same time (publishing, changing the database).
• Editing at the same time. If someone saves the workflow while you're editing, a notice appears at the top of the canvas and Save won't write, so you don't wipe out the other person's change. Use Discard mine and view the new version and redo your change on top.
• Changing a workflow someone is following. Their run keeps counting by the steps of the version it started on (the canvas shows "following version N"). That person's agent is told with their next request, and next time it follows the new version.
• Stopping someone else's run from the dashboard tells their agent with their next request, and the list shows who stopped it.