Describe what you want in plain English. The AI agent writes the computer code, deploys it to your private runtime, and runs it. No coding, no compiling, no deploying -- just a sentence and a result. Each one you keep becomes a named building block you can call again.
A small invisible instruction teaches the AI agent, every turn, to turn a request like "compute the median of this list" or "fetch yesterday's invoices" into actual code, deploy it, run it, and show you the answer. You never see the scaffolding; you never see the deployment ceremony. What you see is a result.
An isolated machine that accepts code over the wire and runs it. Functions persist across calls, so the toolbox accumulates. Today's helper is callable from tomorrow's request.
An invisible instruction tells the AI agent: when the user describes a function in English, write the code, deploy it, run it, render the result. The user types a sentence; the runtime gets a working function.
Every compile, call, and audit query passes through the per-tool authorization map. The AI agent never holds the runtime's credentials and cannot bypass the gate.
Multi-step requests become workflows -- a recorded chain of tool calls. The first run uses the agent and pays the LLM cost. Every replay is just the chain: sub-second, deterministic, no tokens spent, identical results.
Every compile, every call, every approval lands in the per-instance audit log with the originating user. The agent prompt transcript is convenience; the audit log is evidence.
The pipeline you described in an agent prompt at 11pm is named, durable, and re-runnable at 8am. The next workflow can extend it without recompiling, schedule it, or hand it off to another agent.
The user types a function description in plain English. The AI agent picks a name for it, writes the code, pushes it to the runtime, calls it with sample inputs, and renders the results in a small table. The code itself stays hidden unless you ask to see it.
When intent decomposes into more than one call, the AI agent assembles a workflow. Each step is a named function-node call, an HTTP call, a guardrail, or a human approval. The workflow runs as a supervised process with durable state -- pause, approve, cancel, re-run, schedule.
Authoring is slow because the agent is in the loop. Replay is fast because it isn't. Every later run is a deterministic chain of tool calls -- no tokens, no re-deciding, identical results.
"Compute the median of these numbers, dedupe these rows, normalise these timestamps." A single sentence becomes a callable module you can re-invoke without re-prompting.
Pull, transform, post. Read, dedupe, summarise. The first run authors the workflow. Every later run is one call. Re-runnable, schedulable, auditable.
Modules persist on your runtime. Last week's helper is callable from this week's agent. The runtime accumulates the small functions you actually use.
Function Nodes ship with every AI Agent Gateway instance. Same per-tool authorization, same audit log, same self-hosted footprint -- now with a runtime that turns conversations into code.