TaskAGI’s New Edit Data Node: Transform Data Without Writing Code

You can now set, format, and transform data between workflow steps in TaskAGI without touching a single line of code. We’ve added an Edit Data core node that lets you define field values, merge incoming data, and restructure information as it flows through your AI agent workflows.

Here’s what changed: Previously, transforming data or setting variables required either custom code nodes or external tools. Now it’s a visual, point-and-click operation built directly into your workflow canvas.

What the Edit Data Node Does

The Edit Data node is a straightforward but powerful addition to TaskAGI’s core node library. It sits in your workflow like any other node—between your AI model outputs, integrations, or data sources—and lets you explicitly define what data moves forward.

Core capabilities:

• Add and remove fields dynamically with a simple interface
• Assign values to fields with support for multiple data types: strings, numbers, booleans, and JSON objects
• Reference data from other workflow nodes using the [[nodes.X.field]] syntax
• Merge new field assignments with data already flowing from previous nodes

Think of it as a data checkpoint in your workflow. You control exactly what information passes through, what gets transformed, and how it’s structured for the next step.

Why This Matters for Your Workflows

Data transformation is one of those tasks that sounds simple but becomes tedious fast. Whether you’re formatting API responses, setting default values, combining data from multiple sources, or preparing information for a downstream integration, you’ve probably wished for a cleaner way to handle it.

Before the Edit Data node, you had three options, none ideal:

• Write custom code: Slows down workflow building, requires technical knowledge, and makes workflows harder to maintain
• Chain multiple integrations: Uses more API calls and adds unnecessary complexity
• Restructure in your destination tool: Pushes the problem downstream and limits flexibility

The Edit Data node eliminates that friction. It’s purpose-built for this exact task and integrates seamlessly with everything else in your workflow.

Common Use Cases

Setting workflow variables: Create intermediate data points that multiple downstream nodes can reference. For example, after an AI model generates content, use Edit Data to assign it to a field, add metadata, and pass it forward.

Formatting outputs for integrations: APIs expect specific field names and structures. Use Edit Data to reshape your data into exactly what your CRM, email tool, or database expects—without writing a mapper.

Combining data from multiple sources: Pull information from different nodes and merge it into a single structured output. Reference fields from your AI model, a web scraper, and a database query all in one place.

Cleaning up API responses: External APIs often return more data than you need, with inconsistent field names. Use Edit Data to keep what matters, rename fields, and discard the rest.

Adding computed values: Use node references to build new fields based on existing data. For example, concatenate a first name and last name, or calculate a total from multiple number fields.

How to Use the Edit Data Node

The interface is intentionally simple. When you add an Edit Data node to your workflow:

1. Define your fields: Click “Add Field” to start building your data structure. Give each field a name.
2. Set values: For each field, choose a data type (string, number, boolean, or JSON) and enter the value. You can type static values or use node references.
3. Reference other nodes: Use the [[nodes.X.field]] syntax to pull data from earlier steps in your workflow. For example, [[nodes.ai_model.output]] pulls the output field from your AI model node.
4. Choose merge behavior: Toggle whether to merge these fields with incoming data (keeping fields from previous nodes) or use only the fields you’ve explicitly defined.
5. Run your workflow: Connect the Edit Data node to downstream steps. The data it outputs is now structured exactly as you defined it.

The dynamic row interface means you’re not locked into a fixed structure. Add fields as you need them, remove ones you don’t, and adjust on the fly as your workflow evolves.

Node Reference Syntax Explained

The [[nodes.X.field]] syntax is how you pull data from other parts of your workflow into your Edit Data node. Here’s how it works:

• nodes.X = the identifier of the node you’re referencing (visible in your workflow canvas)
• field = the specific output field from that node

Example: If you have an AI model node labeled ai_model that outputs a field called generated_text, you’d reference it as [[nodes.ai_model.generated_text]].

This works with any node type: AI models, integrations, web scrapers, previous Edit Data nodes, or anything else in your workflow.

Merge vs. Replace Behavior

The merge toggle controls what happens to data flowing through the node:

• Merge enabled: Fields you define in Edit Data are added to (or override) existing fields from previous nodes. Other fields pass through unchanged.
• Merge disabled: Only the fields you explicitly define are passed to the next node. Everything else is discarded.

Use merge mode when you want to keep most of the incoming data but add or modify specific fields. Use replace mode when you need a clean data structure and want to be explicit about what moves forward.

Real Workflow Examples

Example 1: AI Content with Metadata

Your workflow: User request → AI model generates content → Edit Data node → Email integration

In Edit Data, you define:

• email_body = [[nodes.ai_model.output]] (pull the AI-generated content)
• subject_line = “New content: ” (static string, or reference another field)
• timestamp = [[nodes.trigger.created_at]] (pull the timestamp from your trigger)
• priority = “high” (static value)

Now the email integration receives a perfectly structured payload with exactly the fields it needs.

Example 2: Data Cleanup from Web Scraper

Your workflow: Web scraper pulls product data → Edit Data node → Database insert

The scraper returns 20 fields, but you only need 5. In Edit Data:

• product_name = [[nodes.scraper.title]]
• price = [[nodes.scraper.cost]]
• description = [[nodes.scraper.details]]
• url = [[nodes.scraper.link]]
• last_updated = [[nodes.scraper.timestamp]]

Everything else is filtered out. Your database gets clean, consistent data without extra noise.

Example 3: Combining Multiple Sources

Your workflow: CRM lookup → AI analysis → Web scraper → Edit Data → Slack notification

You want to send a message that combines data from all three sources:

• customer_name = [[nodes.crm_lookup.name]]
• ai_insight = [[nodes.ai_analysis.recommendation]]
• market_data = [[nodes.scraper.market_trend]]
• message = “Customer: {customer_name} | Insight: {ai_insight} | Market: {market_data}”

Edit Data becomes your data orchestration layer, pulling from multiple places and presenting a unified output to Slack.

Data Types and When to Use Them

Edit Data supports four data types. Choose the right one for your use case:

Type	Use For	Example
String	Text values, names, descriptions, URLs	“customer@example.com” or [[nodes.ai.output]]
Number	Quantities, prices, counts, IDs	99.99 or [[nodes.calculation.total]]
Boolean	True/false flags, toggles, status indicators	true or false
JSON	Complex nested data, arrays, objects	{"key": "value", "items": [1, 2, 3]}

Most of the time you’ll use strings and numbers. JSON is useful when you need to pass complex structured data to integrations that expect nested objects or arrays.

Mistakes to Avoid

Forgetting the node reference syntax: If you want to pull data from another node, use [[nodes.X.field]]. Typing the node name without brackets won’t work—it’ll be treated as a literal string.

Using the wrong field name: Double-check your node identifiers and field names. If you reference [[nodes.ai_model.output]] but the actual field is generated_text, you’ll get an error or empty data.

Disabling merge when you need it: If you turn off merge and only define three fields, those are the only three fields that move to the next node. Everything else disappears. Use merge mode if you want to preserve existing data.

Overcomplicating the structure: Add only the fields you actually need. If your downstream integration only expects three fields, define three fields. Extra data just creates clutter and makes debugging harder.

Edit Data vs. Code Nodes

TaskAGI still supports custom code nodes for complex logic. When should you use Edit Data instead?

• Use Edit Data: Simple field assignment, data formatting, field selection, static values, basic field references
• Use Code: Complex calculations, conditional logic, loops, string manipulation, custom functions

Edit Data is faster to build, easier to understand, and requires zero coding knowledge. Code nodes are more powerful but slower to develop and maintain. Start with Edit Data for straightforward transformations.

FAQ

Can I use Edit Data to filter or conditionally set fields?

Edit Data doesn’t have built-in conditional logic. For conditional field assignment, use a code node or add conditional branches in your workflow before reaching Edit Data.

What happens if I reference a field that doesn’t exist?

The workflow will error or pass an empty/null value. Always verify that your node identifiers and field names match what’s actually in your workflow.

Can I reference fields from nodes that run in parallel?

No. Edit Data can only reference nodes that have already completed their execution. Make sure your node dependencies are set up correctly.

Do I need to define all fields that downstream integrations expect?

Not if you’re using merge mode. If an integration expects 10 fields and you’re only modifying 2, use merge mode and define just those 2. The other 8 pass through from upstream.

Can I use Edit Data to create arrays or nested JSON structures?

Yes. Set a field to JSON type and enter valid JSON. For example: {"items": [1, 2, 3], "metadata": {"created": "2024-01-15"}}

Getting Started

The Edit Data node is available now in TaskAGI’s core node library. Open a workflow, click to add a node, and look for “Edit Data” in the core nodes section. It works exactly like any other node: connect it in your workflow, configure your fields, and run.

Start with simple use cases—setting a few variables or formatting an API response. Once you’re comfortable with the interface and node reference syntax, you’ll find yourself reaching for Edit Data constantly. It’s one of those features that feels small until you realize how much time it saves.