Build Your First Workflow

Build Your First Workflow

This guide will help you build the simplest useful workflow in Feluda Studio.

The workflow will:

1. receive a piece of text;
2. send it to an AI model with a clear instruction; and
3. return the result.

The completed flow will look like:

Input → LLM → Output

You do not need to know how to code.

Before you begin

Make sure that:

• Feluda is installed and open;
• at least one AI provider is connected;
• at least one model is available;
• the selected model responds in Workbench; and
• you understand the result you want the workflow to produce.

If you have not tested the model yet, open Workbench and send a short message before continuing.

What you will build

Your first workflow will summarise a piece of text.

The user will provide the text.

The AI model will create a short summary.

The Output block will return the summary.

This example is small on purpose. It helps you learn the basic Studio process before adding decisions, tools, extra models, or several outputs.

Step 1: Open Studio

Open Studio from the Feluda sidebar.

Studio opens with a canvas where you can build the workflow.

You will also see the available blocks and the controls used to save or test the flow.

Begin with a blank canvas.

Step 2: Add an Input block

Add an Input block to the canvas.

The Input block is the starting point of the workflow.

It receives the text that will be processed.

Move the block to the left side of the canvas so the flow can continue from left to right.

Give the block a clear name when the option is available, such as:

Source Text

A clear name makes the workflow easier to understand later.

Step 3: Add an LLM block

Add an LLM block to the canvas.

The LLM block is the AI step.

It receives the input and sends an instruction to the model you select.

Place it to the right of the Input block.

A simple layout now looks like:

Input     LLM

The blocks are not yet connected.

Step 4: Connect Input to LLM

Create a connection from the Input block to the LLM block.

The connection tells Feluda to pass the user's text into the AI step.

After connecting them, the flow should look like:

Input → LLM

Check that the connection follows the intended direction.

If the connection is missing, the LLM block will not receive the source text.

Step 5: Configure the LLM block

Open the LLM block settings.

Select:

• the AI provider;
• the model; and
• the instruction for the task.

Use the same provider and model that you already tested in Workbench.

For this first workflow, use an instruction such as:

Summarise the user's input in no more than five bullet points.

Include only the main information.
Use plain language.
Do not add details that are not present in the input.

This instruction gives the model a clear task, format, and limit.

Save or apply the block settings.

Step 6: Add an Output block

Add an Output block to the canvas.

Place it to the right of the LLM block.

The Output block returns the result produced by the AI step.

Give it a clear name when possible, such as:

Summary

The canvas should now contain:

Input → LLM     Output

Step 7: Connect LLM to Output

Create a connection from the LLM block to the Output block.

The completed flow should look like:

Input → LLM → Output

Review the direction of both connections.

The Input should lead to the LLM block.

The LLM block should lead to the Output block.

Step 8: Name the workflow

Choose a clear name before saving.

For example:

Summarise Text

A useful workflow name explains what the flow does.

Avoid names such as:

• Test;
• New Flow;
• Workflow 1; or
• Final Version.

Clear names make saved flows easier to find in RunFlows.

Step 9: Save the workflow

Select Save in Studio.

Complete any requested name or description fields.

A useful description could be:

Receives text and returns a plain-language summary in no more than five
bullet points.

Save the flow.

Saving makes the workflow available for later testing and use.

Save again after making important changes.

Step 10: Test the workflow

Use the available test or run option in Studio.

Provide a short piece of sample text.

For example:

The project team completed the first design review on Monday.
Sam will update the draft by Thursday.
Mia will confirm the customer interview dates.
The launch date has not yet been decided.

Start the flow.

The expected output should be a short bullet-point summary that uses only the information provided.

Review the result

Check whether the workflow:

• received the complete input;
• produced no more than five bullet points;
• used plain language;
• included the main details;
• avoided invented information; and
• returned the summary through the Output block.

In the example above, the model should not invent a launch date.

If the result is correct, test another example.

If it is not correct, review the LLM instruction.

Improve the instruction

When the result is too broad, make the instruction more specific.

For example:

Summarise the user's input in no more than five bullet points.

Include:
* completed work;
* named owners;
* deadlines; and
* unresolved questions.

Use only the provided input.
If a detail is missing, do not guess.

Save the updated block and test the flow again.

Change one part at a time so you can see which change improved the result.

Test more than one example

One successful run is not enough.

Test the flow with:

• a normal paragraph;
• a very short message;
• text with missing information;
• text with several names and dates;
• unrelated text; and
• an empty or incomplete input.

Review whether the instruction still produces a useful result.

Test missing information

Use an example such as:

Alex will prepare the report.
The deadline has not been decided.

The model should not create a deadline.

If it does, update the instruction:

Use only the information in the input.
Do not invent missing names, dates, deadlines, or decisions.

Test again after saving the change.

Test unexpected input

Try input that does not match the task.

For example:

Hello.

Decide whether a short summary is acceptable or whether the workflow should return a clearer message.

For a first workflow, it is enough to understand how the model responds.

Later, you can add a decision or validation step to handle unusual input.

Run the saved flow in RunFlows

After saving and testing the flow:

1. open RunFlows;
2. find the saved workflow;
3. select it;
4. choose the option to run it;
5. enter new source text; and
6. review the returned summary.

RunFlows is the main place to use saved workflows.

Studio is where you design and improve them.

If the flow does not appear in RunFlows

Check that:

• the flow was saved;
• it has a name;
• Feluda finished saving it;
• you are viewing the correct flow list; and
• RunFlows has been refreshed when needed.

Return to Studio and save the flow again if necessary.

If the LLM block returns an error

Check that:

• the provider is still available;
• the model is selected;
• the cloud provider account is active when required;
• the local model application is running when using a local model;
• the LLM block contains an instruction; and
• the Input block is connected to the LLM block.

Test the same model in Workbench.

If the model does not respond there either, correct the provider setup before testing the workflow again.

If no result reaches Output

Check the complete path:

Input → LLM → Output

Confirm that:

• Input is connected to LLM;
• LLM is connected to Output;
• the connections follow the correct direction;
• the LLM block produced a result; and
• the Output block is configured to return that result.

Correct the first missing or incorrect connection.

If the result ignores the instruction

Review the LLM block.

Make sure the instruction clearly states:

• the task;
• the required format;
• the length limit;
• the information to include; and
• what the model should not add.

Test the instruction in Workbench when you are unsure whether the problem is the workflow or the model.

Keep the first workflow simple

Do not add extra blocks only to make the workflow look more advanced.

A clear three-block flow teaches the main Studio process:

• add blocks;
• connect them;
• configure the AI step;
• save the flow;
• test the result; and
• run it again with new input.

Add another block only when it solves a specific need.

Useful next improvements

After the first workflow works reliably, you could add:

• a second AI step that extracts action items;
• a classification step;
• a decision with different paths;
• a tool from an installed Gene;
• a Journal step;
• a different output format; or
• another model for a specialised task.

Add one improvement at a time and test the workflow after every change.

A second beginner workflow idea

You can reuse the same three-block structure for another task.

For example:

Input → Extract Action Items → Output

Use an LLM instruction such as:

Read the user's input.

Return a table with:
* Owner
* Action
* Deadline

If an owner or deadline is missing, write "Not provided."
Do not guess.

This shows how the same workflow structure can support a different result.

Protect sensitive information

Before testing with private information, review:

• the provider and model selected in the LLM block;
• whether the model is local or cloud-based;
• whether any tools or external services are used;
• whether all input details are necessary; and
• where the output will be shown or saved.

Use non-sensitive examples while building the first version.

Information sent to a cloud model is handled by the selected provider.

Know when the workflow is ready

Your first workflow is ready for regular use when:

• the three blocks are connected correctly;
• the model and instruction are saved;
• the expected input is clear;
• several examples have been tested;
• missing information is handled;
• the output is easy to review; and
• the saved flow runs successfully in RunFlows.

Continue reviewing important outputs even after the workflow works consistently.

Your first workflow is complete

You have now created a complete AI workflow:

Input → LLM → Output

This simple structure is the foundation for more advanced workflows.

Next, learn about the other block types available in Studio and how to connect and arrange larger workflows clearly.