Skip to content
AI & agents

Use a model where a model is right.Keep the rules where you can read them.

A language model is very good at reading prose and poor at being audited. So in this product it reads the ticket, drafts the sentence, or explains the table — and the queue, the threshold, the tolerance and the approval stay in nodes a colleague can open and change. Both halves are on the same canvas, which is what makes the split visible instead of theoretical.

How it is wired

Four properties, each a design decision rather than a setting

  • Four nodes, not a mode

    prompt · extract · classify · agent

    ai:prompt returns text. ai:extract returns JSON matching a schema you wrote, and retries once with the parse error fed back. ai:classify returns exactly one of your labels. ai:agent runs a tool-calling loop with a mission, an allow-list and a step ceiling. Each is a node like any other — timeout, retry policy, error branch.

  • The model never produces the number

    computed by the graph, explained by the model

    In the graphs that ship with the product, the totals, the variances and the scores are computed by nodes. The model is handed the result and asked to write the sentence beside it. When a figure and a paragraph disagree, you can tell which one was measured — and the paragraph is the one that changes.

  • Every AI node has a way to fail

    __output_error, and used

    The showcase's classifier falls back to a keyword rule set; its commentary node falls back to a plainly-worded sentence and the page is still built. An automation that stops when an inference endpoint has a bad afternoon is not an automation you put in front of customers, and the graph is where that decision belongs.

  • Your endpoint, your data

    Anthropic · OpenAI · Ollama · self-hosted

    Point it at a vendor or at a model you run. Anything OpenAI-compatible works, which includes vLLM, SGLang, LM Studio and llama.cpp on your own hardware — so a deployment that cannot send text to a third party can still use every AI node on this page.

The assistant

It builds graphs, over the API you already have

The in-app assistant is a tool-calling agent with the platform's own surface in front of it: list the catalog, author a workflow, run it, read its logs, query entities, resolve an approval. It is not a wrapper reading your screen — it is a client of the same REST API you are, under the same role checks, which is why what it can do is a fact about your account rather than a promise in a prompt.

  • Saved agent definitions: a mission, a tool allow-list and a step ceiling, referenced by name from any graph
  • The tools it can call are generated from the node catalog, so a node you built in the app is a tool it can use
  • Tool calls are visible as they happen, arguments and results included — a trace, not a summary
  • It works for a viewer exactly as far as a viewer's role does, which is: it can look and it cannot change
The DjiniousWorkflow agents page listing saved agent definitions with their mission, allowed tools and step limits.The DjiniousWorkflow agents page listing saved agent definitions with their mission, allowed tools and step limits.
An agent definition is a record, not a prompt buried in a node. Change the mission once and every graph that references it by name runs the new one.Seeded development stack
Agents outside the app

An MCP server in the same process

POST /mcp speaks the Model Context Protocol: a coding assistant, a scheduled analyst or your own tooling can list the catalog, create a workflow, run it, watch it, read the logs and answer an approval. The tool list is generated from the same catalog the palette reads, so an agent's abilities and a person's stay in step by construction.

  • Scoped djwf_ tokens, minted and revoked per agent
  • The whole engine surface: catalog, workflows, runs, logs, entities, artifacts, waits
  • A node built in this deployment appears in the agent's tool list immediately
  • Provider Interface v1 for machine-to-machine use, with an OpenAPI snapshot committed to the repo
The DjiniousWorkflow node catalog listing tools and their functions, each with the parameters an author — or an agent — needs to call it.The DjiniousWorkflow node catalog listing tools and their functions, each with the parameters an author — or an agent — needs to call it.
An agent's tool list is generated from this catalog — including the twenty-two nodes this deployment built in the app itself, which is why the header reads 352 rather than the 330 that ship. Build one and the agent can call it on its next connection.Seeded development stack
What we will not claim

Three limits, stated here rather than found later

A model's answer is not a fact
Nothing in the product treats model output as authoritative. Where a graph must act on it, the schema is enforced (ai:extract) or the answer is constrained to a label (ai:classify), and the fallback path is wired. A prompt is not a validation.
Cost and latency are yours
The engine does not batch, cache or dedupe model calls for you. A fan-out over ten thousand rows with a prompt node inside it is ten thousand calls, and the graph shows you that before you run it.
The assistant's transcript is not captured on this site
It needs a live model, and a transcript from whichever endpoint the development stack happened to be pointed at is not a property of the product. The agents page and the token panel are photographed because they are structural; the conversation is not.

Bring the process you would not trust a model with

That is the interesting demo. We will build it with the model doing only the part it is good at, and show you where the graph stops it.

DjiniousWorkflowBuild · Run · Watch · Publish

Build the graph, run it on a schedule or a webhook, watch every node as it executes, and leave a page behind — with the run state in the database rather than in whichever process happened to start it.

  1. Build
  2. Run
  3. Watch
  4. Publish

Every screenshot on this site is a capture of the running platform.