Meet Smartunit: Build AI Agents as Flows. Operate Them With Confidence.

AI agents have crossed the demo line. They can reason through a task, call APIs, search internal systems, update records, and hand work to other agents.

But every new capability creates an operational question: What did the agent do? Why did it do it? What could it touch? What did it remember? And how much did it cost?

That is the problem Smartunit is designed to solve.

Smartunit turns AI agents into visible, composable flows. You connect instructions, models, tools, memory, budgets, inputs, and specialist agents in Node-RED. AI Agent Studio sits on top as the control surface: one place to see the agent system, inspect its runs, follow tool calls, browse memory, and track usage.

The result is not another chat box. It is a practical way to build an agent into a system that people can understand and operate.

The Agent Market Has a Control Problem

The market does not lack capable models or impressive prototypes. It lacks a reliable path from a promising agent demo to a working operational product.

A recent study of 306 practitioners and 20 production case studies found that reliability remains the top agent-development challenge. It also found that 68% of production agents execute no more than ten steps before human intervention. In other words, successful teams are not simply chasing maximum autonomy. They are designing systems with clear limits and places for people to take control. Read the production study.

The need for visibility is becoming just as important. NIST describes the complex, multi-step work behind an agent’s simple interface as a hidden world, and is researching evaluation probes that run inside agent workflows and produce machine-readable audit trails. See NIST’s work on agentic AI evaluation.

Security guidance is moving in the same direction. The Cloud Security Alliance argues that agent security begins with scope control: runtime guardrails, traceable actions, and continuous monitoring of whether an agent stayed inside its intended boundaries. Read the CSA guidance.

These are not model-selection problems. They are system-design and operations problems.

An Agent Should Be a Flow You Can See

An agent is more than a prompt. It is a model making decisions inside a workflow, with access to tools and data, under a set of instructions and limits. OpenAI’s practical guide uses the same foundations: models, tools, and instructions, combined with orchestration and layered guardrails. Read the guide.

Smartunit makes those foundations explicit on a flow canvas.

• Inputs decide how work begins: an incoming message, webhook, schedule, application action, or another event.
• Behaviour defines the system instructions, planning approach, iteration limit, and debug mode.
• Models and connections keep the reasoning model and provider endpoint configurable, including fallback paths when needed.
• Skills expose named, typed actions that the agent may call.
• Memory controls what can be retained and whether it belongs to a session or a user.
• Budgets put measurable limits and warning thresholds around tokens or spend.
• Sub-agents separate specialist responsibilities and make delegation visible.

Agent components stay visible on the flow canvas instead of disappearing behind a single prompt.

Because the agent lives inside Node-RED, its skills can reach the same systems as the rest of the flow: APIs, databases, files, webhooks, notifications, internal services, and operational protocols. Existing deterministic automation does not have to be thrown away. It becomes part of the agent’s working environment.

This matters because visual composition creates a shared language. An engineer can inspect the wiring. An operator can understand where a trigger came from. A product owner can see which actions are available. The agent stops being an opaque prompt loop and becomes an architecture the team can discuss.

Put Intelligence Where It Helps, and Constraints Where They Matter

Language models are useful where work is ambiguous: interpreting an incident, choosing a relevant tool, comparing evidence, summarizing a long event history, or deciding which specialist should handle a request.

They are not the right place for every rule.

In a Smartunit flow, deterministic nodes can validate input, normalize data, enforce required fields, guard tool parameters, route failures, and check the final result. The model gets room to reason, while conventional software keeps the hard boundaries hard.

That division is central to dependable agent design:

• Let the model interpret and choose.
• Let the flow validate and enforce.
• Give tools the narrowest useful scope.
• Keep risky actions behind permissions or human approval.
• Record enough of the run to investigate what happened later.

Control does not mean predicting every model response. It means making the agent’s boundaries, actions, state, and cost visible and changeable.

AI Agent Studio Is the Operational Front Door

Flow authoring gives builders the full system. Operators need a clearer view of what is live.

AI Agent Studio turns the running agent system into an operational workspace. Its dashboard brings agents, sessions, activity, tokens, and cost together. The agent canvas shows how each agent is connected to its behaviour, model, provider, memory, budget, tools, and sub-agents.

A conceptual operations view: follow the run from request to tool calls, memory updates, usage, warnings, and final response.

When a run needs attention, the session and event explorer exposes the timeline: the request, agent response, tool requests and results, memory reads and writes, planning and debug events, and usage. A memory explorer shows the facts and records retained for a session. Complete session logs can be exported for deeper review.

This changes the basic operating question from “Did the agent answer?” to “How did the system arrive there?”

Smartunit Operator is currently an alpha preview, and the product boundary is deliberate. Full graph authoring happens in Smartunit’s Node-RED flow editor today. AI Agent Studio provides the approachable operational view and targeted beta configuration, while its broader visual-building experience continues to develop.

Control Is a Stack, Not a Toggle

An autonomous system is only as controlled as the layers around it. Smartunit brings those layers into the same platform:

• Agent budgets define token or spend limits by period and can warn before the limit is reached.
• Memory scopes separate session context from longer-lived user context.
• Typed skill schemas constrain the actions and parameters presented to the model.
• Webhook scopes distinguish authenticated, same-site, and intentionally public entry points.
• Role-based permissions govern resources and operations across the application.
• API tokens inherit the permissions of their owner instead of bypassing them.
• Audit and console logs support operational investigation outside the model trace itself.

No single layer is a complete safety system. Together, they give a team practical places to limit authority, observe behaviour, and intervene.

From an Agent Flow to an Application People Can Use

The agent is only the backend of the experience. A useful product also needs an interface, authentication, data, permissions, deployment, and a way for people to review results.

Smartunit can package React interfaces as versioned screen extensions and connect them directly to flow-backed APIs. That means a team can build the agent workflow, its protected endpoints, its operational view, and the focused application used by an end user without assembling a separate platform for every layer.

The same platform can connect operational inputs, agent logic, deterministic controls, data, permissions, and a focused application.

Consider a commit-to-article workflow we built on Smartunit:

1. A signed-in user selects a GitHub commit in a focused Smartunit screen.
2. A research agent receives only read-only GitHub skills and gathers the relevant code facts.
3. A writer agent turns that evidence into a structured article draft.
4. Deterministic flow nodes validate requests, handle errors, and verify the result.
5. AI Agent Studio exposes the sessions, tool calls, memory, usage, and handoff between the agents.

The user sees a simple application. The team operating it sees the system behind the result.

Built for the Work After the Demo

The next wave of agent adoption will not be won by the product with the most animated chatbot. It will be won by systems that connect to real work and remain understandable when something unexpected happens.

Smartunit is our answer to that need: agents built as flows, deterministic controls around probabilistic reasoning, and AI Agent Studio as the front end for day-to-day operation.

Start with one workflow that matters. Give the agent only the tools it needs. Make every important step visible. Then expand from evidence, not optimism.

Explore Smartunit Operator and see how the pieces fit together.