AI Hierarchy Builder is the canvas. IC Builder is where you draw the chips. Wire ports, drop modules, drill into SoCs, run the whole hierarchy against real devices — Pi, Jetson, ESP32, industrial OT — without leaving AidaIDE.
The Hierarchy Builder fixes the three things that make most AI-agent frameworks unusable for real device work.
Each IC has typed input and output ports. The canvas refuses to connect a string output to a JSON input — you catch the bug at design time, not at midnight on an Arduino call.
Drop an IC onto a Pi in your fleet. Or onto a Jetson cluster. Or onto local CPU. The runner handles SSH, transports the payload, and streams the result back into the next IC in the chain.
When a sub-graph gets useful, wrap it as a SoC. Drag the SoC into other hierarchies. Drill in to edit. Your team builds a library of agent modules instead of copy-pasting prompt files.
From the team-wide workspace down to the individual agent call. The IC Builder tier is where most of your work lives.
Shared library of hierarchies, ICs, and SoCs across your seats. Permissions, version history, and a single source of truth for agent designs.
A named, packaged group of ICs with its own external ports. Drag a SoC into any hierarchy like a single component. Nest SoCs inside SoCs.
An IC is one agent's job: a prompt template, a chosen LLM (or local model), typed input ports, typed output ports, and an optional device target. The IC Builder is the visual editor that snaps it together.
Reusable primitives that live inside ICs: prompt blocks, validators, transformers, file readers, device-command runners. Drop modules into ICs to compose behavior without writing code.
The leaf node: a single call to OpenAI, Anthropic, Gemini, Ollama, or any OpenAI-compatible endpoint. Set defaults globally, override per IC.
The IC Builder is where you spend most of your time. Pads on the left for inputs, pads on the right for outputs, the prompt+model in the middle, modules wired between.
Add input and output ports with type contracts. The canvas validates connections and tells you exactly where the mismatch is.
Use Claude for reasoning ICs, GPT-4 for code ICs, local Ollama for cheap ICs. One canvas, mixed backends.
Bind an IC to a device or fleet. The runner SSHes in, executes the IC, streams output back into the canvas.
Prompt blocks, validators, file readers, command runners. Snap modules in instead of writing wrapper code.
Double-click an IC inside a SoC to drill into it. Esc or breadcrumb to come back. Navigate hierarchies the way you'd navigate a codebase.
Click any image to open it full-size. Same panels, same shortcuts, same SSH connections that the rest of AidaIDE uses.
Not toy demos. These are the patterns engineers reach for when they outgrow shell scripts and copy-pasted prompts.
"What's wrong with these 40 Pis?"
"PLC throwing weird Modbus errors"
Set a default provider, override per IC. Mix cloud and local in the same hierarchy.
Air-gapped plants, customer sites under NDA, and labs metered by the token all have the same problem: the prompt can't leave the building. AidaIDE manages Ollama on your own hardware — the workstation in front of you, or a Jetson three subnets away — and points the agent canvas at it.
Open a saved device, hit Install Ollama on Device, and AidaIDE provisions the model server over SSH. Pull to Device downloads models straight onto the remote host, so the weights live where the inference runs — never round-tripping through your laptop. Already have Ollama somewhere? + Add Remote Host and Connect & Scan find what is already installed instead of making you provision it again.
The Agent panel's Remote Models tab lists what's loaded on each device in your fleet. Point an agent at a Jetson's GPU and the reasoning happens there, next to the data, while you drive it from the desktop. Add to Agents saves that pairing, so a Teams hierarchy can pin different stages to different machines — the heavy reasoning on the workstation, the quick passes on the box next to the hardware.
AidaIDE compacts context to fit a small model's real window and right-sizes
num_ctx per model instead of assuming a cloud-scale budget. When a device GPU runs
out of memory, the run retries on CPU rather than dying.
With the override on, every AI surface routes through the model you picked — the Agent panel, the
code assistant, and the orchestrator plugin, not just the canvas — and nothing touches a cloud
provider. No API key is involved, because no API is called. When the model server errors, you see
what it actually said instead of a bare HTTP 500.
The AI Hierarchy Builder ships in AidaIDE Pro. The base IDE is free forever — Pro unlocks the full AI suite, advanced network scans, and cameras.
For one developer — base IDE included free
or $190/year
save 17% on annual · 5-year price lock
Pro for your whole team
or $700/year
save 17% on annual · 5-year price lock
An IC is the unit of work you design — typed ports, a prompt template, an optional device target, a chosen model. An Agent is the leaf call itself (one call to OpenAI/Anthropic/etc). One IC always wraps one Agent, but the IC adds the structure that makes the Agent reliable.
Yes — that's the point. Each IC can target a device (a Pi, Jetson, ESP32, OT box, whatever's in your AidaIDE Fleet). The runner SSHes in, executes the IC's body there, streams output back into the canvas. The same IC can also be re-targeted to local CPU with one click.
The Hierarchy Builder ships in AidaIDE Pro — $19/mo or $190/yr, and the AidaIDE base app is free, so that is the total. There is no separate Hierarchy add-on. Annual plans get a 5-year price lock. Full pricing & access answers: Hierarchy pricing FAQ.
Activate a Pro key via Help → Activate License, then open AI → Agent Hierarchy Builder (Ctrl+Shift+H). Greyed-out usually means the license is missing, expired, or all 3 device slots are used elsewhere — details in the access FAQ.
OpenAI, Anthropic (Claude), Google (Gemini), Ollama (local), and any OpenAI-compatible endpoint. You bring your own API keys (stored encrypted in the Credential Vault). Set a default provider globally and override per IC.
Yes. Install Ollama on your workstation or on any device in your fleet — one click from the SSH Models tab — pull models directly onto that host, and point the canvas at it from the Agent panel's Remote Models tab. Prompts, source, and output stay on your own hardware, which is what makes this workable on an air-gapped network or a customer site under NDA.
They are if the tooling respects their limits. AidaIDE compacts context to fit the model's real window rather than assuming a cloud-scale budget, sizes num_ctx per model, and retries on CPU when a device GPU runs out of memory. A 7B model on a Jetson handles log triage and config review well; reasoning-heavy ICs are still better on a frontier model, which is why you can mix both in one hierarchy.
The hierarchies, ICs, and SoCs you've built are saved as files in your AidaIDE project. They stay on your machine. If you re-subscribe later, they open back up in the canvas exactly as you left them.
On Teams Pro, yes — the shared workspace syncs ICs, SoCs, and full hierarchies across your 5 seats with version history. On a single Pro seat you can still export/import via files, but there's no automatic sync.
Build agent workflows that survive past the demo. Get the canvas, the IC Builder, and every LLM provider for $19/mo.
