By default, every project in AICODESIT runs your messages through a fixed two-agent loop — a planner and a coder. That covers 80% of tasks. The other 20% need something more deliberate: a code-review step before edits land, a research agent that pulls live data before writing, or three parallel specialists that each tackle a different part of a problem.
That's what the Pipeline Editor is for. It replaces the default loop entirely and lets you define exactly what runs, in what order, with what permissions — all in a visual canvas inside the IDE.
Opening the editor
Click the pipeline icon in the top toolbar of the AI chat panel. The canvas replaces the chat view; the prompt box at the bottom stays put so you can still trigger runs. Click the icon again to return to normal chat.
Your pipeline is saved per-project automatically. You can also save named pipelines to your account and load them onto any project later.
The four node types
Every pipeline is built from four kinds of nodes. Drag them onto the canvas, then connect them by drawing edges from one node's output handle to the next node's input handle.
1. Input
The Input node is your entry point. It receives what the user types in the prompt box and passes it into the pipeline. Most pipelines have exactly one Input node at the top. You can also type a fixed message directly on the node if you want the pipeline to always start with the same context regardless of what the user says.
2. System Prompt
The System Prompt node (purple) lets you write shared instructions that any downstream Agent node can inherit. Think of it as a global persona or context block — "You are a senior backend engineer working on a Node.js API" — without repeating it on every agent card. Connect it to the agents that should use it.
3. Agent
The Agent node (blue) is the core worker. Each one has:
- System prompt — what role this agent plays and what it should focus on
- Model — pick any model you have access to; different agents in the same pipeline can use different models
- Variables — reference
{{user_message}},{{step_N_output}},{{file_tree}},{{project_url}}, and your project's environment variables anywhere in the prompt
By default an Agent can read and respond but can't touch files or call tools. That's intentional — capabilities are granted explicitly via a Tools node.
4. Tools
The Tools node (yellow) is a capability preset you attach to one or more Agent nodes. Connect a Tools node to an Agent and it gains exactly the permissions you toggle on — nothing more.
Available capabilities:
| Capability | What it unlocks |
|---|---|
| read | Read files in the project |
| gather | Collect and summarize context from the project |
| file / edit | Create and edit files |
| delete | Remove files |
| cmd | Run shell commands (build, lint, test) |
| sub-agent | Spawn a child agent mid-step |
| new-agent | Start a fresh agent with a clean context |
| db | Query the project's database |
| image | Generate images |
| video | Generate video |
| Auto-fix | If the agent's output has errors, loop back and try to fix them automatically |
Tools nodes also let you toggle individual OpenAI function tools: read_file, list_files, write_file, fetch_url, and web_search. These are fine-grained and composable — you can give an agent web search without giving it file write access, for example.
Building a pipeline: step by step
Here's how a simple "research, then code" pipeline looks:
- Drop an Input node at the top. It receives the user's message.
- Add an Agent node below it. Set the system prompt to: "You are a research assistant. Search the web and return a concise summary of what the user is asking about." Connect a Tools node with
web_searchenabled. - Add a second Agent node. Set its prompt to: "You are a senior developer. Use
{{step_2_output}}as context and implement what the user asked for." Connect a Tools node withread,file, andeditenabled. - Draw edges: Input → Agent 1 → Agent 2.
- Hit run. The pipeline fires automatically when you type in the prompt box.
That's it. The researcher fetches real-world context; the coder uses it to write better code. Two agents, two tool sets, one clean sequence.
Parallel agents (fan-out)
One node can connect to multiple downstream agents. When you fan out, all of them run at the same time. This is useful when different specialists should work in parallel on independent problems.
At the merge point you choose one of two behaviors:
- Wait for all — collects every agent's output and passes the combined result to the next step. Use this when a synthesizer agent needs the full picture.
- First wins — the first agent to reply cancels the rest and continues the pipeline. Use this when speed matters and any valid answer is good enough.
You can also leave branches independent — no join at all. Each branch produces its own output and they both land in the chat simultaneously.
Watching it run
When a pipeline fires, each node lights up as it becomes active — a glowing border and a live log you can expand to see exactly what the agent received as input and what it produced as output. Completed steps turn green; failed steps turn red. You always know where your pipeline is and what it's doing.
Pipeline ideas to try
- Code review pipeline — Agent 1 reads the diff, Agent 2 checks for security issues, Agent 3 checks for performance regressions. All three run in parallel; a final agent synthesizes the findings.
- Content + code — Agent 1 writes a blog post draft; Agent 2 generates the matching landing page code. Both receive the user's brief simultaneously.
- Bug hunt — Agent 1 reads the error log, Agent 2 locates the relevant file, Agent 3 proposes a fix. Linear, each step feeds into the next.
- Data-driven page — Agent 1 fetches live data via
fetch_url, Agent 2 renders it into a component using the fetched values.
A note on defaults
If you haven't set up a pipeline, the project uses the standard Newman flow — you don't need to configure anything to get started. The Pipeline Editor is there when you outgrow it. Once you do set a pipeline on a project, it fully replaces Newman for that project only; other projects are unaffected.
Ready to build? Open any project in the IDE, tap the pipeline icon in the toolbar, and start connecting nodes.