# Changelog

> What changed in NoClick: the SDK, the API and the app, newest first.

## November 22, 2026

### Narrow a workflow's runs as the app's run log does

New · API, SDK, Docs · Next SDK release

`GET /v1/workflows/{id}/runs` (`workflow.runs()`) listed runs by how they ended and nothing more. It now narrows them as the app's run log does: by how they started (`source`), by the kind of event that started them (`trigger`: `webhook`, `email`, `call`, `agent`, `shared_link`, `error`), to the ones that wait or the ones that don't (`waiting`), and by text in their error (`search`). Each run says both: `trigger` names the kind of event behind a run whose `source` is `trigger`, so a run an email started no longer reads the same as one a webhook did, and `waiting_on` says what a running run waits on (`approval`, `delay`, or for a run from code `agent_turn`). `GET /v1/workflows/{id}/runs/counts` (`run_counts()`) adds `waiting` and `by_trigger`.

A step's choices (`POST /v1/workflows/{id}/steps/{step}/options`, `step.options()`) are now read with read access, the workflow one of your agents runs on included, where they took edit access: someone who can only view a workflow reads them through an account that's theirs to use. A step a canvas hasn't saved yet lists its choices by its `type`, and `connection` names the account to read from in place of the one the step holds. A value that only reads (`step.value("file_browser")`) takes read access too; one that mints or registers something still takes what changing the workflow takes.

```python
intake = noclick.Workflow.from_name("order-intake")
for run in intake.runs(trigger="email", waiting=True):
    print(run.id, "waits on", run.waiting_on)
print(intake.run_counts().by_trigger)
```

```ts
import { Workflow } from "noclick";

const intake = Workflow.fromName("order-intake");
for (const run of await intake.runs({ trigger: "email", waiting: true })) {
  console.log(run.id, "waits on", run.waitingOn);
}
console.log((await intake.runCounts()).byTrigger);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#recent-runs)

### Manage the skills NoClick's builder loads from the API

New · API, SDK, Docs · Next SDK release

The skills NoClick's workflow builder loads on every call were only the app's Settings. `GET /v1/builder_skills` (`BuilderSkill.list()`) lists your account's and those shared with it, `POST /v1/builder_skills` (`BuilderSkill.create()`) makes one, `PATCH /v1/builder_skills/{id}` (`skill.update()`) changes its words or workflow, turns it off for everyone it reaches, or mutes one shared with you for yourself, and `DELETE /v1/builder_skills/{id}` (`skill.delete()`) deletes one you made. They're apart from the Agent Skills folders an agent attaches (`Skill`).

```python
skill = noclick.BuilderSkill.create("Brand voice", description="How we write.", body_text="Short sentences.")
skill.update(enabled=False)
```

```ts
import { BuilderSkill } from "noclick";

const skill = await BuilderSkill.create({ name: "Brand voice", description: "How we write.", bodyText: "Short sentences." });
await skill.update({ enabled: false });
```

[Read more in the guide](https://www.noclick.com/docs/guide/skills.md#skills-for-noclick-s-builder)

### A setting a build leaves for you waits on you, and is no invalid step

Fixed · NoClick app, API, SDK · Next SDK release

When NoClick's builder or a draft can't know a required setting (your sender number, the folder to upload to, the text of a post), it leaves it for you. For a few days such a step read as invalid ("from_number is required"): the builder was told to fix what only you know, so it asked again or said the step couldn't run, and a draft through the API read the same. Now the step's verdict names those settings as `left_for_user`, and the workflow's readiness lists one `left_for_user` issue for the step ("Text Payment Alert: fill in from_number, to_number") beside the account it needs. The step still can't run until you fill them in, but it's yours to do, never an `invalid_config` for the builder. Three more things a build got wrong are fixed with it: a step's own `content` setting (a file's text, a message) is read back and drafted as the setting it is, a Run trigger no longer reports that what was drafted for it wasn't saved, and a reference in a setting that takes a number or has a format (`{{ $('booking').contact_id }}`) is judged when it runs, on every step, where it read as invalid on a step with several operations and kept the workflow's trigger from turning on.

```python
alerts = noclick.Workflow.from_name("Payment alerts")
result = alerts.build("Text me when a Stripe payment fails").wait(timeout=900)
for step_id, verdict in (result.verdicts or {}).items():
    print(step_id, verdict.get("left_for_user"))   # sms ['from_number', 'to_number']: yours to fill in
for issue in (result.readiness or {}).get("issues", []):
    print(issue["code"], issue["message"])         # left_for_user Text Payment Alert: fill in from_number, to_number
```

```ts
import { Workflow } from "noclick";

const alerts = Workflow.fromName("Payment alerts");
const result = await (await alerts.build("Text me when a Stripe payment fails")).wait({ timeoutS: 900 });
for (const [stepId, verdict] of Object.entries(result.verdicts ?? {})) {
  console.log(stepId, verdict.left_for_user);   // sms ['from_number', 'to_number']: yours to fill in
}
for (const issue of result.readiness?.issues ?? []) {
  console.log(issue.code, issue.message);       // left_for_user Text Payment Alert: fill in from_number, to_number
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#read-one-in-full)

### Turn your NoClick assistant's connection back on

New · API, SDK, Docs · Next SDK release

Revoking your NoClick assistant's connection under **Connected apps** turned it off for good, and when it was refused it told you to turn it back on in a place that had no way to. Now its row offers **Restore**, which turns it back on as it was when you revoked it: its groups, monthly cap, auto-approve amount and own approval settings, never wider. `POST /v1/connected_apps/{id}/restore` (`noclick.ConnectedApp.restore`) does the same, for you alone, signed in: a key, an app's code, an agent and any connection are refused. A client you connected still connects again instead (`409`, `reason` `reconnect`), since restoring it would revive only its old tokens, and each connection's `restorable` says which kind it is. `noclick.ConnectedApp` also lists your connections and revokes one, and your assistant's refusals now name where Restore is.

```python
assistant = next(a for a in noclick.ConnectedApp.list() if a.restorable)
if assistant.revoked:
    noclick.ConnectedApp.restore(assistant.id)
```

```ts
import { ConnectedApp } from "noclick";

const assistant = (await ConnectedApp.list()).find((a) => a.restorable);
if (assistant?.revoked) await ConnectedApp.restore(assistant.id);
```

[Read more in the guide](https://www.noclick.com/docs/guide/mcp.md#turn-a-connection-off-and-back-on)

### NoClick's workflow builder is an agent you can read and run

New · Agents, API, Docs

The builder that makes a workflow from a description is now written as an ordinary NoClick agent, and its code is public: [`agents/builder`](https://github.com/noclickapp/noclick/tree/main/agents/builder) holds its definition, its instructions and its build loop, made with the Python SDK. Every step it takes is an API call your own agent can make (`step_types()`, `edit()`, `draft()`, `run()`, a workflow's `readiness`), and what it can't decide it asks your account's owner as any agent does. Run your own from a key with `python -m noclick_builder "Morning brief" "Every weekday at 8, email me today's calendar."`, or change its instructions and tools. NoClick's own builder is moving onto this same agent account by account; until yours moves, `Workflow.build()` works as it did, and it keeps working the same way after.

With it, an agent's `ask` tool takes what `Human.ask` does: `multiple` to choose several, and, for an agent whose NoClick tools change workflows, `connect` (which of your account's connections a workflow step uses) and `secret` (a secret's values, typed on NoClick's page and never shown to the agent). The owner's answer sets the step, and an account holding just one connection that fits answers at once.

```python
import noclick
from noclick_builder import agent as builder   # pip install noclick, then run from agents/builder

brief = noclick.Workflow.create("Morning brief")
built = builder.build(brief, "Every weekday at 8, email me today's calendar.")
print(built.summary)                        # the builder's words
print(built.built, built.readiness)         # the workflow's own facts
```

```ts
// The public builder is written with the Python SDK. From TypeScript, hand NoClick's builder the same request:
import { Workflow } from "noclick";

const brief = await Workflow.create("Morning brief");
const result = await (await brief.build("Every weekday at 8, email me today's calendar.")).wait();
console.log(result.summary, result.built, result.readiness);
```

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#give-an-agent-a-person)

### List the test runs a workflow offers

New · API, SDK, Docs · Next SDK release

`rehearse` plays a test run by its name or key, but nothing listed them: you found one by guessing, or from the error that names them. `GET /v1/workflows/{id}/test_runs` (`workflow.test_runs()`, `workflow.testRuns()`) lists the test runs a workflow offers, as its Test Run screen does: for each trigger an agent comes after, the staged situations NoClick offers (under the workflow's names, with its edits, less the ones it removed), then the runs it authored. Each has its `key` and `name`, the `trigger` it stages on and the staged `message`. And a test run's tool calls now say what they would have sent: a call that carries a message has `outbound`, in `tool_calls` and the `transcript`.

```python
inbox = noclick.Workflow.from_name("Support inbox")
for run in inbox.test_runs():
    print(run.key, run.name, run.message.get("title"))
test = inbox.rehearse(inbox.test_runs()[0].key).wait()
print([call.get("outbound") for call in test.tool_calls])
```

```ts
import { Workflow } from "noclick";

const inbox = Workflow.fromName("Support inbox");
const runs = await inbox.testRuns();
const test = await (await inbox.rehearse({ testRun: runs[0].key })).wait();
console.log(test.toolCalls.map((call) => call.outbound));
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#test-it-against-a-simulated-world)

## November 21, 2026

### Link your phone, and switch the app's popups, from the API

New · API, SDK, Docs · Next SDK release

The numbers you message and call NoClick from, and which of the app's popups you see, were only the app's Settings. `GET /v1/account/phones` (`AccountPhones.get()`) lists the numbers linked to your account, `POST /v1/account/phones` (`AccountPhones.link()`) texts a code to a new one and `POST /v1/account/phones/verify` (`AccountPhones.verify()`) links it with that code, and `DELETE /v1/account/phones/{phone}` (`AccountPhones.unlink()`) unlinks one. A linked number signs in to your account, so these are the signed-in owner's, or a key's that names the new `account:phones` scope, which a key with `*` holds only when it's named too. `GET /v1/popups` and `PATCH /v1/popups` (`Popups.get()`, `Popups.update()`) read and switch the app's popups and banners, from any of your account's own keys. Both are changes on `watch()`: `phones` and `popups`.

```python
challenge = noclick.AccountPhones.link("+14155550123")
noclick.AccountPhones.verify(challenge.id, "123456")
noclick.Popups.update({"invite_banner": True})
```

```ts
import { AccountPhones, Popups } from "noclick";

const challenge = await AccountPhones.link("+14155550123");
await AccountPhones.verify(challenge.id, "123456");
await Popups.update({ invite_banner: true });
```

[Read more in the guide](https://www.noclick.com/docs/guide/phone-numbers.md#link-your-own-phone-to-your-account)

### A workflow's Approval step names who answers it

New · API, SDK, Agents · Next SDK release

An Approval step always asked your account's owner, for 7 days, and then ended its run. Now its settings name its own `approver` (`{"email"}`, `{"user_id"}`, `{"agent_id"}` or `{"code": true}`, the shapes your account's approval routing takes), how long they have (`expires_in_s`, 60 seconds to 7 days) and what an unanswered one does (`on_timeout`: `decline` ends the run, `escalate` asks the next approver up: your account's, then the owner). A step that sets none follows your account's approver, then the owner, for 7 days, so with nothing set it works as before. An agent named approver reads waiting steps beside held calls on its `approvals` turn and answers them with `approvals__answer`; it approves only a run its own tools could start, and never one its own turn or an ancestor's started. Each step's `noclick.WorkflowApproval` reads who it waits on (`approver`, `on_timeout`) and which agent decided (`decided_by_agent`).

```python
noclick.Workflow.from_name("Invoices").add_step("approval", settings={
    "title": "Pay this invoice?", "approver": {"agent_id": "Finance lead"},
    "on_timeout": "escalate", "expires_in_s": 3600})
```

```ts
import { Workflow } from "noclick";

await Workflow.fromName("Invoices").addStep("approval", { settings: {
  title: "Pay this invoice?", approver: { agent_id: "Finance lead" }, on_timeout: "escalate", expires_in_s: 3600,
} });
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#name-who-answers-a-step)

### Set an agent's budget for one run

Improved · API, SDK, Docs · Next SDK release

A budget lowered for one job used to stay lowered, and the jobs after it were refused. Now `budget_for_run` with `budget_usd_per_month` on `PATCH /v1/agents/{id}` (`agent.update(budget_usd_per_month=2, budget_for_run=True)`) sets the budget for the agent's turn under way, else its next one, and the budget it replaced comes back as that run ends, however it ends. The agent's `budget_restore` says what comes back meanwhile, and the run's outcome says `budget_restored` once it has. It's judged as any budget change: from an agent through MCP, a raise for one run still waits for the owner. An app's coding job says in its outcome what it spent against its agent's budget (`budget`), however it ended.

```python
coder = noclick.Agent.from_name("coder")
coder.update(budget_usd_per_month=2, budget_for_run=True)
print(coder.budget_restore)   # {'budget_usd_per_month': 10.0, 'operation_id': None}
```

```ts
import { Agent } from "noclick";

const coder = Agent.fromName("coder");
await coder.update({ budgetUsdPerMonth: 2, budgetForRun: true });
console.log(coder.budgetRestore);   // { budgetUsdPerMonth: 10, operationId: null }
```

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#a-budget-for-one-run)

### Read what a workflow's canvas reads when it opens

Improved · API, SDK · Next SDK release

Reading a workflow's graph now says what you may do with it and whose agent it is: `access` (`owner`, `editor` or `viewer`, as the app's canvas judges it) and `agent` (the agent whose own flow it is, `yours` when it's your account's own) on `GET /v1/workflows/{id}/graph` (`graph().access`, `graph().agent`). And `GET /v1/workflows/{id}/outputs` (`latest_outputs()`) says how each step's latest run ended, `last_runs` (its `status`, when it finished and its `error`), the marks the app's canvas shows beside each step. With them, a canvas opens a workflow through the API alone.

```python
graph = noclick.Workflow.from_name("Order intake").graph()
print(graph.access, graph.agent)   # owner None
latest = noclick.Workflow.from_name("Order intake").latest_outputs()
print({step: run.status for step, run in latest.last_runs.items()})   # {'hook': 'succeeded', ...}
```

```ts
import { Workflow } from "noclick";

const intake = Workflow.fromName("Order intake");
const graph = await intake.graph();
console.log(graph.access, graph.agent); // owner null
const latest = await intake.latestOutputs();
console.log(Object.fromEntries(Object.entries(latest.lastRuns).map(([step, run]) => [step, run.status])));
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#what-a-step-produced)

### Hear what an edit set going, find workflows by what they say, and delete a folder

Improved · API, SDK, Docs · Next SDK release

A trigger an edit added registered after its answer, so code that wanted the webhook's address read the workflow again until it showed up. Now `settle` on `POST /v1/workflows/{id}/edits` (`edit(settle=True)`) waits up to 30 seconds for what the edit set going and answers how it went: `settled`, the graph as that left it (a trigger's `webhook_url`, an inbox's address), and `unregistered`, why each trigger it left unregistered can't be registered yet; `workflow.settle()` does the same for earlier edits, changing nothing. An edit's `warnings` say when a workspace member gave a team workflow's step a connection of their own its owner's automatic runs can't use. `GET /v1/workflows?search=` (`Workflow.list(search=...)`) finds workflows by text in their name or description, and `DELETE /v1/workflows/folders/{id}` (`Workflow.delete_folder()`) deletes a folder as the app does, its workflows moving up a level. NoClick's own workflow builder now makes every read and write this way, as a connected app of your account named in Connected apps.

```python
brief = noclick.Workflow.from_name("Morning brief")
with brief.edit(settle=True, include_graph=True) as e:
    e.add_step("trigger-webhook", id="hook", name="Order placed")
print(e.result.graph.step("hook").settings["webhook_url"])

for workflow in noclick.Workflow.list(search="digest"):
    print(workflow.name)
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
const result = await brief.edit({ settle: true, includeGraph: true }, (e) => {
  e.addStep("trigger-webhook", { id: "hook", name: "Order placed" });
});
console.log(result?.graph?.step("hook").settings.webhook_url);

for (const workflow of await Workflow.list({ search: "digest" })) console.log(workflow.name);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#several-changes-at-once)

### The builder's questions are human requests, answered anywhere

Improved · API, SDK, NoClick app · Next SDK release

What NoClick's builder asked came back as a page only a person could answer when it was an account or a secret, and only through the build. Now each input of a build's question is a [human request](https://www.noclick.com/docs/guide/humans.md) to the person whose build it is (`request_id` on each input, `sent_to` saying where NoClick sent them), so it's answered wherever any request is: its page, the chat's card, their texts, or your code. A setting picked from an account is asked once that account is connected, and one the account holds only one of answers itself. The build goes on once every one is answered. `POST /v1/workflows/{id}/builds/{operation_id}/answer` (`build.answer()`) still answers it all at once, now accounts too (a connection's ref or name) and an agent step's environment (`secret_values`, kept as your secret), from a key acting for your whole account. And no question has to be answered: `questions: "assume"` on a build or a new workflow (`questions="assume"`) has the builder ask nothing, deciding and saying what it assumed.

```python
import os

build = noclick.Workflow.from_name("Morning brief").build("Post it to Slack too")
if (question := build.next_question(timeout=900)) is not None:
    build.answer({"slack": "credential:5f1c…"},
                 secret_values={"env": {"WAREHOUSE_TOKEN": os.environ["WAREHOUSE_TOKEN"]}})

noclick.Workflow.from_name("Morning brief").build("Text me as well", questions="assume")
```

```ts
import { Workflow } from "noclick";

const token = process.env.WAREHOUSE_TOKEN ?? "";
const build = await Workflow.fromName("Morning brief").build("Post it to Slack too");
if ((await build.nextQuestion({ timeoutS: 900 })) !== null) {
  await build.answer({ slack: "credential:5f1c…" }, { secretValues: { env: { WAREHOUSE_TOKEN: token } } });
}

await Workflow.fromName("Morning brief").build("Text me as well", { questions: "assume" });
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#when-the-builder-asks)

### File workflows in folders, and read what NoClick's builder reads

New · API, SDK, Docs · Next SDK release

Your account's workflow folders were only the app's. `GET /v1/workflows/folders` (`Workflow.folders()`) lists them as its Automations page shows them, `POST /v1/workflows/folders` (`Workflow.create_folder()`) makes one, at the top or in another, and `POST /v1/workflows/{id}/move` (`workflow.move_to()`) files a workflow in one or takes it out to the top; a workflow's `folder_id` says where it is. And what NoClick's builder reads before it builds is yours to read: `GET /v1/workflow_examples` (`workflow_examples()`) lists NoClick's example workflows, found by what they're for, and `GET /v1/workflow_examples/{id}` (`workflow_example()`) reads one whole, its guidance and its workflow's graph. Through the MCP server, `search` finds them and `fetch` reads them, beside the docs the builder reads, `ref:builder.<topic>`.

```python
weekly = noclick.Workflow.create_folder("Weekly", parent=noclick.Workflow.create_folder("Reports"))
noclick.Workflow.from_name("Morning brief").move_to(weekly)

[best] = noclick.workflow_examples("triage support email", limit=1)
print(noclick.workflow_example(best.id).text)
```

```ts
import { Workflow, workflowExample, workflowExamples } from "noclick";

const weekly = await Workflow.createFolder("Weekly", { parent: await Workflow.createFolder("Reports") });
await Workflow.fromName("Morning brief").moveTo(weekly);

const [best] = await workflowExamples("triage support email", { limit: 1 });
console.log((await workflowExample(best.id)).text);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#folders)

### Let an agent administer, and let your code make keys

New · API, Agents, SDK · Next SDK release

Over MCP, your policy's rules, resuming a user's spending, unfreezing a card and loosening what an agent may do (a coding agent's permission mode, app testing, model switching, Docker on your machines, a card to pay with) were out of every agent's reach, so only a person in the console made them. Now a connected app or an agent you grant the new `admin` group reaches them: an agent with `"noclick.admin"` in its tools, a connected app whose client asks for `admin` by name and you tick it at consent. Nothing holds it unnamed, `"noclick"` alone and NoClick's assistant included. Each call is a new kind of hold, `admin` or `elevate`, refused by default and switched like any other for your account, a key or connected app, or one agent, to `ask` (held for you, and your own message to the agent is your yes) or `allow`. And one of your account's keys naming the new `keys:create` scope makes secret keys (`Key.create`), each no wider than itself in scopes, cap, expiry and approval settings, and revoked with it.

```python
noclick.ApprovalPolicy.set(settings={"elevate": "ask"})
ops = noclick.Agent.create("ops", instructions="Keep the coding agents moving.", tools=["noclick", "noclick.admin"])

worker = noclick.Key.create("queue worker 7", ["queues", "agents"], spend_cap_usd_per_month=20)
```

```ts
import { Agent, ApprovalPolicy, Key } from "noclick";

await ApprovalPolicy.set({ settings: { elevate: "ask" } });
const ops = await Agent.create("ops", { instructions: "Keep the coding agents moving.", tools: ["noclick", "noclick.admin"] });

const worker = await Key.create("queue worker 7", ["queues", "agents"], { spendCapUsdPerMonth: 20 });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#let-an-agent-or-a-connected-app-administer)

### Your agents connect your accounts to the workflows they build

New · Agents, API, SDK · Next SDK release

An agent editing one of your workflows through `POST /v1/workflows/{id}/edits` couldn't give a step a connection the workflow didn't already use, nor an agent step a secret, so building a workflow stopped at every account it needed. Now it attaches your account's own connections (`set_connection`) and secrets (an agent step's `secrets`) in your account's own workflows, as you would on the canvas, never another member's connection, one of your users' or one held for someone else. Each one is a version of the workflow naming the key it came through. It's a new kind of hold, `attach_connection`, allowed by default and switched like any other for your account, a key or connected app, or one agent: asked, the edit waits for your yes from the link NoClick sends you; denied, it's refused and the agent asks you which account the step should use.

```python
noclick.ApprovalPolicy.set(settings={"attach_connection": "ask"})
```

```ts
import { ApprovalPolicy } from "noclick";

await ApprovalPolicy.set({ settings: { attach_connection: "ask" } });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#let-agents-attach-your-connections)

### A canvas saves its every change as edits

Improved · API, SDK · Next SDK release

A canvas built on `edit(source="canvas")` still had parts of a person's work it couldn't send: an edge drawn from an agent's output handle was refused, a connection filed under the slot the step reads it from (one Anthropic key on a Claude Code agent) was refused, and the Interface tab's layout had nowhere to go. Now a canvas's edge joins the handles it names, its connection sits under the slot it gives (one the step takes), and `update_workflow(interface=...)` saves the layout as part of the graph. `origin` names the canvas on its batch (`edit(origin=...)`), so the workflow's other open canvases take its write as another's and the one that sent it skips what it holds already, and `keepalive: true` in TypeScript (`EditOptions`, and `RequestOptions` for any call) sends a closing tab's last batch after its page has gone. Sent with no `if_version`, that batch lands on the workflow as it stands: its removal, edge or change of something another writer took away meanwhile is moot, its result saying `gone`, and the rest of it still lands. NoClick's own canvas saves this way, starting with NoClick's staff.

```python
brief = noclick.Workflow.from_name("Morning brief")
with brief.edit(if_version=brief.graph().version, source="canvas", origin="canvas-tab-1") as e:
    e.connect("summarize", "post", handle="right", target_handle="left", id="xy-edge__summarize-post")
    e.update_workflow(interface={"layout": [{"i": "post", "x": 0, "y": 0, "w": 6, "h": 4}]})
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
await brief.edit({ source: "canvas", origin: "canvas-tab-1", keepalive: true }, (e) => {
  e.updateStep("summarize", { settings: { system_prompt: "Keep it short." } });
});
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#save-it-as-a-canvas-does)

### Send held calls to a supervisor agent, a person, or your code

New · Agents, API, SDK · Next SDK release

Every call NoClick held went to your account's owner. Now who answers is a setting: `routing` on `PUT /v1/approvals/policy` (`ApprovalPolicy.set(routing=...)`), and `approvals.routing` on a key, a connected app or an agent, names the approver: the owner, a person by email, one of your users, one of your agents, or your own code with a key holding `approvals:answer`. A supervisor agent is woken once for every call waiting on it, answers them all in one `approvals__answer` call, approves only what it could do itself (never a deletion that can't be undone), and answers its children's and their children's calls, so it can sit at the top of its own line, but never its own call or an ancestor's. `expires_in_s` gives the approver its time, and `on_timeout` `escalate` passes an unanswered call to the next approver up, finally the owner, instead of declining it. An owner NoClick can't reach passes the call on too. An approval now says who it waits on (`approver`) and who decided (`decided_by` `person` or `agent`). With nothing set, the owner approves, as before.

```python
noclick.ApprovalPolicy.set(routing={"approver": {"agent_id": "supervisor"}, "on_timeout": "escalate",
                                    "expires_in_s": 3600})
```

```ts
import { ApprovalPolicy } from "noclick";

await ApprovalPolicy.set({ routing: { approver: { agent_id: "supervisor" }, on_timeout: "escalate", expires_in_s: 3600 } });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#route-held-calls-to-another-approver)

### Domains and numbers your app's code buys, with no one asked

New · API, SDK, Docs · Next SDK release

Every domain an app's code bought, and every number it filed a holder for, waited for your yes: the registrar's agreement and the holder's details are a person's to give. Now they're given once and kept on file. Set `terms` and `person_filing` to `standing` (`PUT /v1/approvals/policy`, `noclick.ApprovalPolicy.set()`) and a call what's on file covers runs with nobody asked; one nothing covers is refused at once with the step that files it, never held. A user has a registrant profile of their own, with their own acceptance of the agreement (`PUT /v1/domains/registrant` acting for them, `Domain.set_default_registrant(contact, user=...)`), used when a purchase for them names no registrant, as your account's default is. A number holder's profile (`PUT /v1/phone_numbers/holder`, `PhoneNumber.set_holder_profile()`) is filed by a purchase with `holder_on_file`. A name with a trademark notice is refused under `standing`, since a person reads it for each name. And your own server can ask for machines for your company with a key that names the new `machines:vetting` scope, saying who accepted the usage policy and when (`accepted_by`, `accepted_at`). With nothing switched, every hold stands as before.

```python
noclick.ApprovalPolicy.set(settings={"terms": "standing", "person_filing": "standing"})
noclick.Domain.set_default_registrant(ana, user="user_42")   # with Ana's agreement_accepted_at
noclick.PhoneNumber.set_holder_profile(holder, accepted_at=accepted_at, user="user_42")
```

```ts
import { ApprovalPolicy, Domain, PhoneNumber } from "noclick";

await ApprovalPolicy.set({ settings: { terms: "standing", person_filing: "standing" } });
await Domain.setDefaultRegistrant(ana, { user: "user_42" });
await PhoneNumber.setHolderProfile(holder, { acceptedAt, user: "user_42" });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#terms-and-filings-kept-on-file)

### Build, run and test a team's workflow you can edit

Improved · API, SDK · Next SDK release

A workflow you could edit but didn't pay for, in a team workspace someone else owns or shared with you to edit, was yours to edit through the API but not to build, draft, run or test: those were refused. Now each takes edit access, as the app's canvas does: `build()`, `draft()`, `run()` (from one step too), `rehearse()` and `stop_run()` work on it, billed as the app bills it, to the account that pays for the workflow, with you named on each charge as who ran it. That account's balance and monthly cap decide whether the work starts: when it can't pay, the refusal says its workspace's owner lifts it (`billed_to: "workspace_owner"`) and carries none of your payment links. Your key's own cap still counts what you spend there. Pausing and deleting it, and publishing its app, stay its payer's.

```python
team_flow = noclick.Workflow.from_id("4f0c…")   # access: "editor"
team_flow.run({"order_id": "o_1042"}).wait()    # charged to the workspace's owner
```

```ts
import { Workflow } from "noclick";

const teamFlow = Workflow.fromId("4f0c…");   // access: "editor"
await (await teamFlow.run({ order_id: "o_1042" })).wait();   // charged to the workspace's owner
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#shared-and-team-workflows)

### Build, run, test and publish a team's workflow you can edit

Improved · API, SDK · Next SDK release

A workflow you could edit but didn't pay for, in a team workspace someone else owns or shared with you to edit, was yours to edit through the API but not to build, draft, run, test or publish: those were refused. Now each takes edit access, as the app's canvas does: `build()`, `draft()`, `run()` (from one step too), `rehearse()` and `stop_run()` work on it, billed as the app bills it, to the account that pays for the workflow, with you named on each charge as who ran it. That account's balance and monthly cap decide whether the work starts: when it can't pay, the refusal says its workspace's owner lifts it (`billed_to: "workspace_owner"`) and carries none of your payment links. Your key's own cap still counts what you spend there. `publish()`, `step.publish()`, `rename_app()` and `unpublish()` work on its app too, which stays the workflow owner's, its hosting billed to the account that pays for the workspace's work. Pausing, deleting and moving it stay its payer's.

```python
team_flow = noclick.Workflow.from_id("4f0c…")   # access: "editor"
team_flow.run({"order_id": "o_1042"}).wait()    # charged to the workspace's owner
```

```ts
import { Workflow } from "noclick";

const teamFlow = Workflow.fromId("4f0c…");   // access: "editor"
await (await teamFlow.run({ order_id: "o_1042" })).wait();   // charged to the workspace's owner
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#shared-and-team-workflows)

### One agent can buy or delete without asking, within your ceiling

New · Agents, API, SDK · Next SDK release

An agent's purchases and deletions that can't be undone always waited for you, whatever its tool rules said. Now an agent has approval settings of its own: `approvals` on `POST /v1/agents`, `PATCH /v1/agents/{id}` and `POST /v1/agents/{id}/children` (`approvals=` on `noclick.Agent.create()`, `agent.update()` and `agent.spawn()`) set what its own calls wait for, in place of the account's, never looser than your account's ceiling. An agent allowed purchases under $20 buys a $19 number at once and asks about a $21 one. A child follows its parent's settings and only tightens them, and tightening the parent tightens its children at once. NoClick's assistant is an agent like any: tell it "you can buy things under $20 without asking me" and its own purchases follow, recorded as your word. A tool rule allowing `noclick.spend` or `noclick.delete` now means allow. An agent loosening its own settings or another's on its own initiative waits for your yes, and `ApprovalPolicy.get(agent_id=...)` and `explain(..., agent_id=...)` read what one agent meets. What an agent holding everything does on a stranger's turn beyond the connection it answers on (`outside_other_connection`) is now set per agent too.

```python
noclick.ApprovalPolicy.set(ceilings={"purchase": {"disposition": "allow", "under_usd": 50}})
noclick.Agent.from_name("buyer").update(approvals={"purchase": {"disposition": "allow", "under_usd": 20}})
```

```ts
import { Agent } from "noclick";

await Agent.fromName("buyer").update({ approvals: { purchase: { disposition: "allow", under_usd: 20 } } });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#set-them-for-one-agent)

### Tell your agent to stop asking before a connection's action

Improved · Agents, API, Docs · Next SDK release

A connection's approval rule now lifts the way your agents' own approval settings loosen. Tell NoClick's assistant, or any agent of yours whose NoClick tools reach connections, "stop asking me before Gmail sends", and it lifts that rule at once, recorded as yours with the agent and turn it came through. An agent lifting one on its own initiative (a schedule's or a wake-up's turn, someone else's message), a connected app and a key used through MCP wait for your yes from the link NoClick sends you: the `loosen_approvals` kind, a default you can switch. Your code never answers that approval, and an app's code still never lifts one.

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#lift-it)

### Lift a connection's approval rule from your code

New · API, SDK, Docs · Next SDK release

`require_approval` makes a connection's owner approve each call of an operation, and until now only the owner, signed in to the app, could take that back. `DELETE /v1/connections/{ref}/require_approval` (`connection.lift_approval()`) lifts it: at once for the owner signed in, and from your server for one of your account's own keys naming the `approvals:policy` scope, after the 10-minute undo window every key's loosening waits, with the owner told. `noclick.ApprovalPolicy.undo(change.id)` takes a key's lift back meanwhile, and so does requiring approval for that operation again. No agent, MCP connection or app's code lifts one, and one shared with your account stays its owner's. Each lift, the app's included, is kept with your account's approval changes (`scope` `credential`) and is an `approvals.policy.changed` event.

```python
[change] = noclick.Connection.from_name("gmail").lift_approval("delete_message")
print(change.pending, change.effective_at)
```

```ts
import { Connection } from "noclick";

const [change] = await Connection.fromName("gmail").liftApproval("delete_message");
console.log(change.pending, change.effectiveAt);
```

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#lift-it)

### Have NoClick draft a workflow's steps

New · API, SDK · Next SDK release

You lay a workflow's graph out with edits; NoClick's drafter now fills it in. `POST /v1/workflows/{id}/drafts` (`Workflow.draft`) has the drafter the app's builder uses pick each step's operation and fill its settings, the steps together, on NoClick's own drafting models, reading each step's goal and what the steps before it output. `mode` picks the operation and settings (`full`), the operation alone, the settings of the operation a step has, or one setting. It's a `workflow.draft` operation that reports each step as it lands, then writes them as one version of the workflow, as an edit with your key does, and settles with each step's verdict (its `references` among it), the settings it wrote and the ones it left for you. It costs the drafter's AI usage at cost.

```python
brief = noclick.Workflow.from_name("Morning brief")
drafted = brief.draft([{"id": "fetch", "goal": "Read today's unread email"},
                       {"id": "post", "goal": "Post a summary of it to #team"}]).wait()
print(drafted.steps["post"]["operation"], drafted.steps["post"]["unfilled"])   # send_message_to_channel ['channel']
```

```ts
import { Workflow } from "noclick";

const op = await Workflow.fromName("Morning brief").draft([
  { id: "fetch", goal: "Read today's unread email" },
  { id: "post", goal: "Post a summary of it to #team" },
]);
const drafted = await op.wait();
console.log(drafted.steps.post.operation, drafted.steps.post.unfilled);   // send_message_to_channel ["channel"]
```

- `Workflow.draft(steps, mode=, field=, instructions=)` takes `Step`s, their ids, or `{"id", "goal"}`; a drafted step keeps its goal. `WorkflowDraftResult` is what its operation settles with.
- A step it couldn't draft is left as it was, with its `error`; a setting it left for you keeps the value you set; it never connects an account. A step the workflow doesn't have, a note, a step that gives an agent its tools or a setting the step doesn't have is refused before anything runs.

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#have-noclick-draft-a-step)

### An edit names the reads of other steps that won't resolve

Improved · API, SDK · Next SDK release

A step that reads another's output with a key that output doesn't have (`{{ $('summarize').txt }}` for a step that outputs `text`) passed every edit and resolved to nothing when it ran. Now each step an edit touches says so: its verdict (`POST /v1/workflows/{id}/edits`' `steps`, `Step.verdict`) carries `references`, each read that won't resolve with the keys that step's output is known to have, or naming the step it likely means when the workflow has no step by that name. It's the app's builder's own check, judged against what each step's type declares, its latest output in this workflow and what your account's own runs of that type showed, never another account's. `Step.references` reads them.

```python
summary = noclick.Workflow.from_name("Morning brief").step("send_summary")
summary.update(settings={"body": "{{ $('summarize').txt }}"})
print(summary.references)   # [{"field": "body", "step": "summarize", "key": "txt", "known_keys": ["text", "usage"]}]
```

```ts
import { Workflow } from "noclick";

const summary = await Workflow.fromName("Morning brief").step("send_summary").update({ settings: { body: "{{ $('summarize').txt }}" } });
console.log(summary.references);   // [{field: "body", step: "summarize", key: "txt", known_keys: ["text", "usage"]}]
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#change-it-step-by-step)

### Test a workflow against a simulated world from code

New · API, SDK · Next SDK release

The app's Test Run plays a staged event to a workflow's agents while a simulated world answers every tool call; now code can play one too. `POST /v1/workflows/{id}/rehearsals` (`workflow.rehearse()`) plays a test run the workflow offers, by its name or key (a staged situation for one of its triggers, or one authored with `add_test_run`), or a message you type on one of its trigger steps, through the same launcher as the app's: nothing is sent, no account is touched, and the steps after an agent that would reach an account never run. Its `workflow.rehearse` operation settles with the agent's reply, the tool calls it made with what the world answered, the run step by step and its cost. It's billed and judged as the app's Test Run is (the agents' turns, and the world's answers as AI testing), a write that waits for no one.

```python
test = noclick.Workflow.from_name("Support inbox").rehearse("Refund request").wait()
print(test.reply, [call["tool"] for call in test.tool_calls])
```

```ts
import { Workflow } from "noclick";

const test = await (await Workflow.fromName("Support inbox").rehearse({ testRun: "Refund request" })).wait();
console.log(test.reply, test.toolCalls.map((call) => call.tool));
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#test-it-against-a-simulated-world)

### A canvas saves through edits, and checkpoints are named versions

New · API, SDK · Next SDK release

A canvas built on the SDK couldn't save the way the app's canvas does: an edit rewrote or refused what a person typed, couldn't take a setting out, and a workflow one of your agents runs on, or one in a team's workspace someone else pays for, couldn't be edited at all. `POST /v1/workflows/{id}/edits` now takes `source: canvas` (`workflow.edit(source="canvas")`): each setting it sends replaces that setting and is kept as written, the step's verdict saying what it still needs, and its saves join the canvas session's version. A setting sent as `null` is taken out, for any edit. An edge can be named by its caller and join a step's named input (`target_handle`), a note can sit where it was put, and `update_workflow` takes `display_metadata`, what the app shows of the workflow, which is never a version. An agent's workflow is edited as its canvas edits it, the agent following its prompt, harness and model; a team's workflow is edited with edit access. A version can now be named (`POST /v1/workflows/{id}/versions`, `workflow.name_version()`): kept for good while it has its name, which is what a checkpoint in the app now is, and `versions(named=True)` lists them.

```python
brief = noclick.Workflow.from_name("Morning brief")
saved = brief.name_version("Before the Slack change")
with brief.edit(source="canvas") as e:
    e.update_step("summarize", settings={"system_prompt": "Keep it short.", "temperature": None})
brief.restore(history_version=saved.history_version)
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
const saved = await brief.nameVersion("Before the Slack change");
await brief.edit({ source: "canvas" }, (e) => {
  e.updateStep("summarize", { settings: { system_prompt: "Keep it short.", temperature: null } });
});
await brief.restore({ historyVersion: saved.historyVersion });
```

#### Upgrade

An edit that sent a setting as `null` stored a null; it now takes the setting out (a run reads both the same way). An edit of the workflow one of your agents runs on no longer raises `PermissionDenied`.

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#save-it-as-a-canvas-does)

### Follow a workflow's runs step by step, and stop one

New · API, SDK · Next SDK release

A run's steps showed only once it ended, and only the app could stop one. Now `GET /v1/workflows/{id}/runs/{run_id}` (`workflow.get_run()`) shows each step as the run gets there, `running` and then how it ended with its output (never a secret), however the run started, and `watch` says when to read it again: a `workflow_run` change naming the run and its workflow, `step` when a step moved and `run` when it started or ended. A run from code reports its steps on its operation too, which the agent that started it hears. `POST .../runs/{run_id}/stop` (`workflow.stop_run()`) stops a running run as the app's stop does, judged as starting one is; for a run from code it's the operation's cancel, and canceling the operation now stops what it's running at once. `GET .../runs/counts` (`workflow.run_counts()`) counts what `runs()` lists, by status and by how each started.

```python
intake = noclick.Workflow.from_name("order-intake")
for run in intake.runs(status="running"):
    print([(step.name, step.status) for step in intake.get_run(run.id).steps])
    intake.stop_run(run.id)
```

```ts
import { Workflow } from "noclick";

const intake = Workflow.fromName("order-intake");
for (const run of await intake.runs({ status: "running" })) {
  console.log((await intake.getRun(run.id)).steps.map((step) => [step.name, step.status]));
  await intake.stopRun(run.id);
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#follow-a-run-as-it-goes)

### Ask which account a workflow step uses, or for a secret it needs

New · API, SDK · Next SDK release

A question can now fill in a workflow's step, written as whoever answers. `Human.ask(connect=...)` (`connect` on `POST /v1/humans/requests`) asks your account's owner which of its connections a step uses: their page lists the ones that fit and connects another through the provider's sign-in, NoClick sets their choice on the step as them, and an account holding just one that fits answers at once. `Human.ask(secret=...)` asks for a secret's values on NoClick's page, whose link carries a key so the request's id alone opens nothing; the values go into your account's secret by that name, never into the request, its answer or anything a model reads, and with `step` the agent step's shell gets it too. Your code answers either with the new `HumanRequest.answer` (`connection`, or `secret_values`), from a key acting for your whole account.

```python
flow = noclick.Workflow.from_name("Morning brief")
owner = noclick.Human.owner()
owner.ask("Which Slack should the Post step use?",
          connect={"integration": "slack", "step": {"workflow": flow, "step_id": "post"}})
owner.ask("The warehouse API token, please.",
          secret={"name": "warehouse", "keys": ["WAREHOUSE_TOKEN"], "step": {"workflow": flow, "step_id": "summarize"}})
```

```ts
import { Human, Workflow } from "noclick";

const flow = Workflow.fromName("Morning brief");
const owner = Human.owner();
await owner.ask("Which Slack should the Post step use?", {
  connect: { integration: "slack", step: { workflow: flow, stepId: "post" } },
});
await owner.ask("The warehouse API token, please.", {
  secret: { name: "warehouse", keys: ["WAREHOUSE_TOKEN"], step: { workflow: flow, stepId: "summarize" } },
});
```

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#ask-which-account-a-workflow-step-uses-or-for-a-secret-it-needs)

### Connect a workflow step by its connection's name, and give an agent step secrets

Improved · API, SDK · Next SDK release

An edit's `set_connection` took only a credential's id. It now takes any of your account's connections as `GET /v1/connections` gives it: its ref (`credential:<id>` for one connected in the app, a named connection's id or `connection:<id>`) or a named connection's name, and the step takes the account it holds. A connection that's one of your users', holds no working account yet, or isn't your account's is refused, naming it; a credential's id still works. An agent step now takes your account's [secrets](https://www.noclick.com/docs/guide/secrets.md) by name in its `secrets` setting (`step.update(secrets=[...])`): their keys are in its shell's environment on every run, its model is told only their names, and no read of the workflow shows a value. Only a key acting for the whole account that owns the workflow gives a step either; any other caller, an agent's own tools included, keeps what the workflow already has.

```python
brief = noclick.Workflow.from_name("Morning brief")
brief.step("post").set_connection("work-slack")
brief.step("summarize").update(secrets=["warehouse"])
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
await brief.step("post").setConnection("work-slack");
await brief.step("summarize").update({ secrets: ["warehouse"] });
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#change-it-step-by-step)

### Ask a person to pick from their own account, or to choose several

Improved · API, SDK · Next SDK release

`Human.ask` takes `pick`, as `POST /v1/humans/requests` and an agent's `ask` tool already did: something in one of the person's connected accounts (which repository, channel or sheet), its choices read from the account, so they pick from their own, and an account holding just one answers at once with it. The answer names the choice in the account too, as `Answer.value`. A new `multiple` lets them choose several of the options, or of a pick's choices: the request's page shows a box for each, and the answer names each one, `Answer.choices` (with a pick's `values`); `POST .../answer` takes them as `choices`.

```python
answer = noclick.Human.owner().ask(
    "Which repositories should the reviewer watch?",
    pick={"connection": "github", "field": "repository"},
    multiple=True,
).wait()
print(answer.values)
```

```ts
import { Human } from "noclick";

const request = await Human.owner().ask("Which repositories should the reviewer watch?", {
  pick: { connection: "github", field: "repository" },
  multiple: true,
});
console.log((await request.wait()).values);
```

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#pick-from-a-connected-account-or-choose-several)

### Publish an interface step from code, with no build

New · API, SDK · Next SDK release

A workflow's interface went live from code only through a build's `publish`, an operation to wait on. `POST /v1/workflows/{id}/steps/{step}/publish` publishes one step's app as the app's canvas does and answers at once: `action` `publish` (a `subdomain` the first time; the saved edits at the address it has after), `rename` (another address, no edits) or `unpublish` (to the trash for 30 days, restored there or by publishing again). It answers the app as a build's `published` names it, its `state` and `url`, with its `project_id` and `subdomain`, and is judged as a build's publish is: a change that needs `deploy` through MCP, with no approval asked. In the SDKs it's `step.publish()`, `step.rename_app()` (`renameApp`) and `step.unpublish()`.

```python
page = noclick.Workflow.from_name("Morrow Bakehouse site").step("page")
print(page.publish("morrow").url)
```

```ts
import { Workflow } from "noclick";

const page = Workflow.fromName("Morrow Bakehouse site").step("page");
console.log((await page.publish({ subdomain: "morrow" })).url);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#publish-an-interface-step-without-a-build)

### A workflow build says whether it's ready, not only what the builder says

Improved · API, SDK · Next SDK release

A finished build's result now carries facts no model wrote beside the builder's `summary`: whether it `built` anything (`False`: the workflow is as it was), the `version` it ended on, its `readiness` as `GET /v1/workflows/{id}` reads it, and each step's verdict (`verdicts`) as an edit answers them. A build that left settings the run engine would reject goes back to the builder with them before it finishes, at most twice (`sent_back`). A fact that couldn't be read is `None` and named in `unread`, never passed off as ready.

```python
brief = noclick.Workflow.from_name("Morning brief")
result = brief.build("Also post the brief to #team on Slack").wait(timeout=900)
for issue in (result.readiness or {}).get("issues", []):
    print(issue["step"], issue["message"])
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
const result = await (await brief.build("Also post the brief to #team on Slack")).wait({ timeoutS: 900 });
for (const issue of result.readiness?.issues ?? []) console.log(issue.step, issue.message);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#what-a-finished-build-says)

### Each step's latest output, an expression's preview and what a step outputs

New · API, SDK · Next SDK release

What the app's canvas reads about a workflow's steps is on the API too. `GET /v1/workflows/{id}/outputs` (`workflow.latest_outputs()`) reads every step's latest output at once, each without its secrets, named in `withheld`. `POST .../steps/{step_id}/expression` (`step.preview_expression()`) evaluates an expression as a run would, against what the other steps last stored or samples you pass, and changes nothing. `GET /v1/step_types/{step_type}/output_shape` (`noclick.step_output_shape()`, `stepOutputShape()` in TypeScript) reads what a step of a type outputs, learned only from your account's own runs. `POST .../steps/{step_id}/clear_state` (`step.clear_state()`) forgets what a step keeps between runs (an RSS feed's seen items, an agent step's conversations), as the app's Clear state does; clearing an agent step deletes its conversations for good, so it's a deletion, previewed first and, through MCP, held for the account's owner.

```python
intake = noclick.Workflow.from_name("order-intake")
print(intake.latest_outputs().outputs["hook"])
print(intake.step("summarize").preview_expression("$('hook').items.length").preview)
```

```ts
import { Workflow } from "noclick";

const intake = Workflow.fromName("order-intake");
console.log((await intake.latestOutputs()).outputs.hook);
console.log((await intake.step("summarize").previewExpression("$('hook').items.length")).preview);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#try-an-expression)

### A step's dropdown choices and widgets, from code

New · API, SDK · Next SDK release

Code editing a workflow step by step could read a step's settings schema, but not the choices a dropdown setting takes (the spreadsheets in the connected Google account, a workspace's channels) or what a widget beside the settings shows (a trigger's address). `POST /v1/workflows/{id}/steps/{step}/options` (`step.options(field)` in both SDKs) lists a setting's choices, read by the step's own lookup in the account connected to it, a page at a time, with unsaved `settings` laid over the saved ones. `POST /v1/workflows/{id}/steps/{step}/values` (`step.value(field)`) loads a widget's value: a trigger's address, minted and registered, an app's event subscription, a filesystem step's files, an alarm's schedules, an MCP step's hosted link. Both answer as the app's canvas does and never carry a secret: `withheld` names what was left out. Loading a value that registers something is a write over MCP, one that only reads a read, and a hosted MCP link's URL is out of reach there.

```python
sheet = noclick.Workflow.from_name("Morning brief").step("read_sheet")
choices = sheet.options("spreadsheet_id").options
address = noclick.Workflow.from_name("Order intake").step("hook").value("webhook_url").values["webhook_url"]
```

```ts
import { Workflow } from "noclick";

const { options } = await Workflow.fromName("Morning brief").step("read_sheet").options("spreadsheet_id");
const { values } = await Workflow.fromName("Order intake").step("hook").value("webhook_url");
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#a-step-s-choices-and-widgets)

### Run a workflow from one of its steps

New · API, SDK · Next SDK release

A run from code always started at a workflow's trigger, so trying a step you just changed meant running everything before it again, and a step after a trigger only its app's events start couldn't be run at all. `POST /v1/workflows/{id}/runs` now takes `from_step` (`workflow.run(from_step=...)`, `step.run()`): that step and what comes after it run, the steps before it giving the outputs they last stored, as the app's Run from here does; `only` runs the step alone. It's checked, judged and charged as any run is. A step that provides an agent its tools has no run of its own and is refused, saying to run from the agent.

```python
intake = noclick.Workflow.from_name("order-intake")
print(intake.step("summarize").run(only=True).wait().outputs)
```

```ts
import { Workflow } from "noclick";

const intake = Workflow.fromName("order-intake");
console.log((await (await intake.step("summarize").run({ only: true })).wait()).outputs);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#run-from-a-step)

### What a step produced, run by run

New · API, SDK · Next SDK release

Code that builds or debugs a workflow could read a run's steps cut to a thousand characters, but not what one step produced across runs, nor the whole of it. `GET /v1/workflows/{id}/steps/{step_id}/outputs` (`step.outputs()`) lists a step's outputs newest first, each with its run, how that run started, the step's status there and a one-line preview, a trigger's deliveries included, with `search` to find the one holding some text. `GET .../outputs/{run_id}` (`step.output(run_id)`) reads one run's: cut short, whole (`full`), or only the part at a `path`. No read of an output shows a secret: a webhook's request headers and anything named like a key or a token are left out, each named in `withheld`, and a run's own `steps` now leave them out the same way.

```python
hook = noclick.Workflow.from_name("order-intake").step("hook")
latest = hook.outputs(limit=1)[0]
print(latest.preview, hook.output(latest.run_id, path="items[0].sku").output)
```

```ts
import { Workflow } from "noclick";

const hook = Workflow.fromName("order-intake").step("hook");
const [latest] = await hook.outputs({ limit: 1 });
console.log(latest.preview, (await hook.output(latest.runId, { path: "items[0].sku" })).output);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#what-a-step-produced)

### Every step a workflow can hold, and the settings each takes

New · API, SDK · Next SDK release

Code building a workflow step by step could find an integration in `/v1/integrations`, but not NoClick's own steps (triggers, agents, conditions, loops, interfaces, tables, code, email), and no step's settings. `GET /v1/step_types` (`noclick.step_types()`, `stepTypes()` in TypeScript) lists every kind of step, NoClick's own first, or with `q` finds them by name or by what they do, ranked as the app's builder ranks them: each with its operations, which of them start runs and need an account, and the accounts a step of it connects to. `kind=trigger` keeps what a run can start from, `kind=tool` what an agent can use as its tools. `GET /v1/step_types/{step_type}` (`noclick.step_type()`, `stepType()`) reads one with its settings schema, the same one the app's canvas draws a step's form from.

```python
[send] = noclick.step_types("send an email", limit=1)
schema = noclick.step_type(send.type).schema
```

```ts
import { stepType, stepTypes } from "noclick";

const [send] = await stepTypes("send an email", { limit: 1 });
const { schema } = await stepType(send.type);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#find-a-step-s-type-and-settings)

### Every charge says which workstream it belongs to

New · Billing, SDK, API · Next SDK release

An agent now names the workstream its work belongs to as it starts it, the way it titles it: a child's task (`Agent.spawn(..., workstream=)`, `POST /v1/agents/{id}/children`), a message its `agents` tools send, an app's coding job (`POST /v1/projects/{id}/live/changes`), from your workstreams or a new name. Everything the work starts belongs to it too, and every charge recorded inside it says which (`metadata.workstream_id`). `noclick.usage(group_by="workstream")` and `Usage.series(group_by="workstream")` split spend by it, each group with the workstream's `name`. `noclick.Workstream.list()` (`GET /v1/workstreams`) reads your workstreams with what each spent this month, and `Workstream.rename()` (`PATCH /v1/workstreams/{name}`) renames one, or merges it into another by naming that one; charges are read through the rename and never rewritten.

```python
for workstream in noclick.Workstream.list():
    print(workstream.name, workstream.spent_usd)
noclick.Workstream.rename("Menu", "Bakery site")
```

```ts
import { Workstream } from "noclick";

for (const workstream of await Workstream.list()) console.log(workstream.name, workstream.spentUsd);
await Workstream.rename("Menu", "Bakery site");
```

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#which-workstream-each-charge-belongs-to)

### Archive a workstream, and see which one each job belongs to

New · Billing, SDK, API · Next SDK release

`Workstream.archive()` (`PATCH /v1/workstreams/{name}` with `archived: true`) puts away a workstream whose work is done: its charges still read under it, and it leaves `Workstream.list()` and the workstreams agents choose from. `Workstream.list(archived=True)` lists the archived ones, each `archived`, and `Workstream.unarchive()` brings one back, as an agent naming it again does. A single operation's view, its wait and `Operation.list()` now name the workstream its work belongs to as it reads now (`operation.workstream`, `{id, name}`), and so does a coding agent's current job in `Agent.coding()`; `watch` sends a `workstream` change when one is renamed, merged, archived or brought back. In NoClick's app, Settings → Workstreams renames and archives them, Settings → Usage splits the month by workstream, each charge says who it was for and which workstream, and a helper agent's card in Work and in the chat names its job's workstream.

```python
noclick.Workstream.archive("Q3 launch")
print([w.name for w in noclick.Workstream.list(archived=True)])
```

```ts
import { Workstream } from "noclick";

await Workstream.archive("Q3 launch");
console.log((await Workstream.list({ archived: true })).map((w) => w.name));
```

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#which-workstream-each-charge-belongs-to)

### One key or connected app can do more, or less, without asking

New · API, SDK · Next SDK release

Your account's approval switches now have narrower scopes. `approvals` on `PATCH /v1/keys/{id}` (`noclick.ApprovalPolicy.set_for_key()`, `setForKey()` in TypeScript) and on the new `PATCH /v1/connected_apps/{id}` (`set_for_connected_app()`, `setForConnectedApp()`) set what one key or connected app waits for, in place of the account's, never looser than the account's ceiling: lowering the ceiling tightens every key and connection at once. A connected app's auto-approve amount, chosen once at consent, is now changed there too, and NoClick's assistant's grant is one of them: give it an amount and its purchases under it go through. A purchase code makes now comes under its connection's amount, priced as it's made. Say it to your agent and it happens: a loosening asked for on a turn your own message started takes effect, recorded as yours with the key and the agent it came through, while one a model makes on its own (a schedule's turn, a connected app, someone else's message) waits for you. Tightening goes through from any caller, a connected app tightening itself included. A key holding `approvals:policy` loosens one after a 10-minute undo window, and nothing loosens its own on its own initiative.

```python
noclick.ApprovalPolicy.set(ceilings={"purchase": {"disposition": "allow", "under_usd": 50}})
noclick.ApprovalPolicy.set_for_key(key_id, {"purchase": {"disposition": "allow", "under_usd": 20}})
```

```ts
import { ApprovalPolicy } from "noclick";

await ApprovalPolicy.setForConnectedApp(appId, { autoApproveUnderUsd: 10 });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#set-them-for-one-key-or-connected-app)

### Hear when your account's cap or its email alerts change, on watch

New · Billing, API, SDK · Next SDK release

`watch()` now follows `spend_cap` and `notifications`: a change that says your account's monthly cap was set, changed or removed (`status` `capped` or `uncapped`), or that the email alerts NoClick sends you were switched, from Settings, the API or an email's unsubscribe link. A page showing either reads it again instead of polling. Only the account hears them (`spend_cap` with a key that holds the `usage` scope, or signed in); a key acting for one of your users doesn't. Settings in the app now reads and changes both through the API.

```python
for message in noclick.watch(objects=["spend_cap", "notifications"]):
    if message.type == "change":
        print(message.object, message.status)
```

```ts
import { watch } from "noclick";

for await (const message of watch({ objects: ["spend_cap", "notifications"] })) {
  if (message.type === "change") console.log(message.object, message.status);
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/watch.md#what-a-change-says)

### Watch sends its token as the socket's first frame

Improved · SDK, API · Next SDK release

`watch()` now opens its socket offering only the `noclick.watch` subprotocol and sends its token as the socket's first frame, `{"type": "auth", "token": "<token>"}`, as NoClick's other live sockets do. It used to offer the token beside the subprotocol, in a request header, which logs on the way can keep. The token's `url` now carries a ticket, which lets a socket wait for that one token and nothing more, so a socket opened without one never reaches the stream. A socket that puts its token in a header or the URL is refused before it opens. One whose first frame isn't its token closes with 4400, one that sends nothing within 30 seconds with 4408, and one whose ticket another socket is already waiting with 4409; `watch()` reconnects from each with a new token, as it does from any drop.

#### Upgrade

Code that calls `watch()` needs no change, and a server handing a page its token passes `url` on as it is. Code that opens the socket itself opens that `url` and sends the token first:

```ts
import { watchToken } from "noclick";

const token = await watchToken({ origin: "https://app.example.com" });
const socket = new WebSocket(token.url, "noclick.watch");
socket.onopen = () => socket.send(JSON.stringify({ type: "auth", token: token.token }));
```

[Read more in the guide](https://www.noclick.com/docs/guide/watch.md#in-a-browser)

### A connection names the account it holds, so a step's account matches it

Improved · API, SDK · Next SDK release

A workflow step keeps the id of the account a connection holds, not the connection's own id, so code reading a step couldn't tell which named connection it used. Now each connection says it: `credential_id` on `GET /v1/connections` and `GET /v1/connections/{ref}` (`connection.credential_id`, `connection.credentialId` in TypeScript), `null` until an account is connected. Match it to a step's `connections` to name the account a step uses. It's only an id, named only on the connections the caller can read: a user's key sees its user's, and an app's code never another app's.

```python
step = noclick.Workflow.from_name("Morning brief").graph().step("post")
mine = {c.credential_id: c for c in noclick.Connection.list() if c.credential_id}
print(mine[step.connections["slack_oauth"]].name)   # work-slack
```

```ts
import { Connection, Workflow } from "noclick";

const step = (await Workflow.fromName("Morning brief").graph()).step("post");
const mine = new Map((await Connection.list()).map((c) => [c.credentialId, c]));
console.log(mine.get(step.connections.slack_oauth)?.name);   // work-slack
```

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#wait-for-the-user)

### Switch the owner's email alerts, and lower the account's cap, from a key, a connection or an agent told to

New · API, SDK, Billing · Next SDK release

The email alerts NoClick sends your account's owner (a failed automation, a low balance, the monthly cap reached, a disconnected account, the weekly digest, and the rest) were only switched in Settings → Notifications in the app, or off one at a time from each email's link. `GET /v1/notifications` (`noclick.Notifications.get()`, `Notifications.get()` in TypeScript) reads every kind, on or off, and `PATCH /v1/notifications` (`Notifications.update`) turns any of them on or off in one change, with any of your account's own keys or an MCP connection. Settings reads and writes the same switches. An agent switches them only on the owner's own word: a turn their message started.

Your account's [monthly cap](https://www.noclick.com/docs/guide/spend.md#your-account-s-monthly-cap) can now be lowered, or set where there's none, by more than its owner: any of your account's keys (`noclick.Usage.set_account_cap(50)`, `Usage.setAccountCap` in TypeScript, `PUT /v1/usage/limits/account`), an MCP connection, and an agent on the word of the person whose message started its turn, your account's owner or someone who joined one of your spaces. Tell an agent to lower the cap and it does; on a schedule's turn it's refused. Raising or removing it still waits for the owner. Each change records who made it: `noclick.Usage.limits().account.set_by` names the person (`responsible_user_id`), the key, the connection and the agent of the last one.

```python
noclick.Notifications.update({"digest": False})
noclick.Usage.set_account_cap(50)
```

```ts
import { Notifications, Usage } from "noclick";

await Notifications.update({ digest: false });
await Usage.setAccountCap(50);
```

[Read more in the guide](https://www.noclick.com/docs/guide/webhooks.md#email-alerts-to-your-account-s-owner)

## November 20, 2026

### Read the account's whole ledger, as Settings → Usage does

New · Billing, API, SDK · Next SDK release

`usage()` adds up what your keys and agents spent in the calendar month. The ledger is every charge your account was billed in its billing period: your automations' runs, your chat with NoClick, a teammate's work you pay for, and your keys' and agents' calls. It's the same read Settings → Usage draws on noclick.com, now on the API.

- `GET /v1/usage/groups` (`noclick.Usage.ledger()`, `Usage.ledger()` in TypeScript) groups the charges of this period and the one before by day, in a time zone you pick, and by every field a breakdown splits by. It names the automations, agents, people, apps and keys they were for.
- `POST /v1/usage/charges` (`Usage.charges()`) lists the charges inside any groups, or on one day, a page at a time.
- `GET /v1/usage/billing` (`Usage.billing()`) reads the money behind them as the credit gate reads it: the plan and its pools, the balance, funds added and what's scheduled to be charged.

You, signed in, and your account's own secret keys read them; a key reads the money without auto top-up or friends' credit. Through MCP, no agent or connected app reads them.

```python
ledger = noclick.Usage.ledger(tz="Europe/London")
print(sum(g.usd for g in ledger.groups if g.current and not g.own_resource))
```

```ts
import { Usage } from "noclick";

const ledger = await Usage.ledger({ tz: "Europe/London" });
console.log(ledger.groups.filter((g) => g.current && !g.ownResource).reduce((sum, g) => sum + g.usd, 0));
```

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#the-account-s-ledger)

### Hear when your account is charged, on watch

New · Billing, API, SDK · Next SDK release

`watch()` now follows `usage`: a change that says your account was charged, or given a charge back, so a page that shows spend reads it again instead of polling. A burst of charges is one change, a few seconds after the first of them. It names nothing about them: no id, amount, service or user. Only the account hears it, with a key that holds the `usage` scope or signed in; a key acting for one of your users doesn't.

```python
for message in noclick.watch(objects=["usage"]):
    if message.type == "change":
        print(noclick.usage().total_usd)
```

```ts
import { usage, watch } from "noclick";

for await (const message of watch({ objects: ["usage"] })) {
  if (message.type === "change") console.log((await usage()).totalUsd);
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/watch.md#what-a-change-says)

### A container app's DATABASE_URL, a login of each release's own

New · Apps, API, SDK · Next SDK release

A container app had no lasting way to reach its Postgres database over the wire: a connection URL saved as a setting stopped working within a day, and a binding put a description of the database in its environment, which no ORM reads. Now each container release gets a login of its own to each Postgres database the app binds, as `DATABASE_URL` (or `<binding>_URL` each, when it binds several or sets `DATABASE_URL` itself), which Django, Rails and Prisma read as it is. It works for as long as the release can serve: a rollback or a promote releases it again with a new one, retiring the release or moving the app to the trash ends it, a paused database keeps it, and a restore of the database makes it again. A preview gets its branch's own copy of the database, or production's for an app whose previews share production's data. A deploy's `databases` says where each went (a SQLite database has no URL: its code reaches it through the SDK), and a deployment's `variables` names everything its environment held, never a value.

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#a-container-s-database-url)

### Switch off what NoClick holds for a person, kind by kind

New · API, SDK, Agents · Next SDK release

No call has to wait for a person for good. `PUT /v1/approvals/policy` (`noclick.ApprovalPolicy.set`, `ApprovalPolicy.set` in TypeScript) switches each kind of hold for your whole account to `allow`, `ask` or `deny`, in place of NoClick's default for every caller: a purchase, a deletion that can't be undone or one to the trash, purging the trash, turning auto-renew on, raising a spending limit, and what an agent answering someone outside does. A purchase may be allowed under an amount, and any setting may lapse at a time (`until`). Only the signed-in owner or a key naming the new `approvals:policy` scope switches them; letting purchases or deletions through past the default needs a monthly spending cap on the account; a key's loosening takes effect after a 10-minute undo window (`ApprovalPolicy.undo`) and tells the owner. Every change is kept (`ApprovalPolicy.history`) and is an `approvals.policy.changed` event, and `ApprovalPolicy.explain` says what a call would meet, and why.

```python
noclick.ApprovalPolicy.set(settings={"purchase": {"disposition": "allow", "under_usd": 20}, "purge": "allow"})
```

```ts
import { ApprovalPolicy } from "noclick";

await ApprovalPolicy.set({ settings: { purchase: { disposition: "allow", under_usd: 20 }, purge: "allow" } });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#switch-them-for-your-account)

### Answer a workflow's Approval step from your phone, the chat or your code

New · NoClick app, API, SDK · Next SDK release

A run waiting at a workflow's Approval step could only be answered in a screen the app no longer has, so every one waited until it expired 7 days later. Now NoClick asks your account's owner as soon as the run starts waiting, the way it asks about a held purchase: a one-tap link on the app they text NoClick on (else by email), or a card with Approve and Decline in the web chat while they're there. Your code answers it too: `GET /v1/workflows/{id}/approvals` lists a workflow's steps, and `POST /v1/workflows/{id}/approvals/{approval_id}/answer` approves or declines one, signed in as the owner or with a key that names `approvals:answer`. The run goes on once, down that branch, whoever answers first; `workflow.approval.requested` and `workflow.approval.decided` events tell a webhook as each is asked and answered.

```python
for approval in noclick.Workflow.from_name("Invoices").approvals(status="pending"):
    approval.approve(note="Checked.")
```

```ts
import { Workflow } from "noclick";

for (const approval of await Workflow.fromName("Invoices").approvals({ status: "pending" })) {
  await approval.approve({ note: "Checked." });
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#answer-its-approval-steps)

### Read what NoClick holds for a person by default, kind by kind

New · API, SDK · Next SDK release

Every call NoClick holds for a person is now one named kind of hold (`purchase`, `delete`, `purge`, `raise_limit`, `terms`, `outside_change`, ...), with a default for each kind of caller: a connected app, NoClick's assistant, an agent's tools, a key used through MCP, code a connected app runs and an app's own code. `GET /v1/approvals/policy` (`noclick.ApprovalPolicy.get()`, `ApprovalPolicy.get()` in TypeScript) reads them: what each kind holds, who approves it, and its default for each caller. Nothing that's held changed: the same calls wait for the same person, with the same reason on the approval.

```python
policy = noclick.ApprovalPolicy.get()
print(policy.default("purchase", "connected_app"))   # under_auto_approve
```

```ts
import { ApprovalPolicy } from "noclick";

const policy = await ApprovalPolicy.get();
console.log(policy.default("purchase", "connected_app")); // under_auto_approve
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#what-waits-by-default)

### Size a container: CPU, memory, warm instances, CPU between requests

New · API, Apps, SDK · Next SDK release

Every container ran at 1 vCPU and 512 MiB with CPU only during a request and 5 minutes a request, so a bot stalled between requests, a socket was cut at 5 minutes and an ML model ran out of memory. An app's `container` settings now size it: `cpu` (0.5 to 8), `memory` (MiB), `min_instances` kept warm (up to 3), `max_instances`, `cpu_always` (CPU between requests) and `request_timeout_s` (up to an hour), each refused past its bound by name. They cost what the container costs NoClick, nothing added: `container.idle_usd_per_month` says what warm instances cost with nothing calling the app, and settings whose idle cost alone passes the app's budget are refused. `min_instances` applies at once; the rest from the next release.

```python
bot = noclick.Project.from_name("ticket-bot")
bot.update(container={"cpu_always": True, "min_instances": 1})
print(bot.container.idle_usd_per_month)
```

```ts
import { Project } from "noclick";

const bot = Project.fromName("ticket-bot");
await bot.update({ container: { cpuAlways: true, minInstances: 1 } });
console.log(bot.container.idleUsdPerMonth);
```

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#size-a-container)

### A rollback runs with today's secrets, and every promote is looked at

Fixed · Apps, SDK · Next SDK release

A rollback used to put back the release exactly as it was uploaded, its secrets included, so a key you had revoked or rotated came back with it. Every promote and rollback is now released again with the app's settings, secrets and bindings as they are now (a second or two for a site, a new revision for a container), and once production serves it its home page is asked as a deploy's is: one that answers wrong stays live, and its `warning` says what answered. A rollback to a release from before one of your Durable Object classes parks the class, its data kept, where it used to be refused with advice to delete the class (`deployment.parked`). Promoting a deployment past the rollback window builds its commit again checked as any promote is, and says so (`deployment.rebuilt`). Undoing a promote restores the app's databases to before it, taking out what was written since (kept in the trash, below): the promote's operation now says that before you undo it (`undo_rewinds`, `undoRewinds` in TypeScript), and the undo says it again. Two production deploys finishing at once can no longer leave the older one live, and a release that can't be routed after it was built reads failed, with its `deployment.failed` event, rather than ready.

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#roll-back)

### A database restore keeps what it rewinds, so undoing a promote loses nothing

Fixed · API, Apps, SDK · Next SDK release

Restoring a database to a moment, by `restore()` or by undoing a promote, threw away every write since that moment, and on Postgres for good. Each restore now keeps what the database held just before it in the trash for 30 days, as a database copy (`TrashItem` kind `database_copy`): undoing the restore's operation, or restoring the copy from the trash, puts it back, with a restore of its own that keeps a copy the same way. A restore's operation names its copy (`kept_copy_id`), and an undone promote's result lists one per database (`copies`). Since nothing a restore rewinds is gone for good, an agent restores a database, or undoes a promote, without asking anyone, as it deletes to the trash. A Postgres copy's storage is charged at Neon's price while it's kept, as the database's is.

```python
from datetime import datetime, timedelta, timezone

before = datetime.now(timezone.utc) - timedelta(hours=2)
restore = noclick.Database.from_name("orders").restore(at=before)
restore.wait()
restore.undo()   # the writes it rewound are back
```

```ts
import { Database } from "noclick";

const before = new Date(Date.now() - 2 * 60 * 60 * 1000);
const restore = await Database.fromName("orders").restore({ at: before });
await restore.wait();
await restore.undo();   // the writes it rewound are back
```

[Read more in the guide](https://www.noclick.com/docs/guide/undo.md#undo-an-operation)

### Unpublishing an app moves it to the trash, so it no longer waits for you

Improved · Apps, Agents, SDK · Next SDK release

Taking down an app NoClick publishes from an automation (`project.unpublish()`, `workflow.unpublish()`, removing its interface step, or Unpublish in the app) now moves it to the trash rather than deleting it. It stops answering and its page's key stops working at once, but for 30 days no other app takes its address, and restoring it, or publishing its interface again, serves it there with the same key. `unpublish()` returns its `TrashItem`, and a build that unpublished names it (`published["trash_id"]`, `trashId` in TypeScript). Because it can be undone, an agent, a connected app or NoClick's assistant now unpublishes as a change that needs `deploy`, with nothing held for you unless your policy or the connection asks before changes. Purging it from the trash deletes it for good, and still waits for your approval.

#### Upgrade

`Project.unpublish()` returns a `TrashItem` where it returned nothing. A connection no longer needs `delete` to unpublish, and an agent can make the call directly rather than through the `delete` tool.

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#apps-noclick-publishes)

### Agents in a workspace hand work to helpers for the people who joined it

Improved · Agents, API

An agent's turn for someone who joined one of your workspaces can now spawn a child, a helper, as it can for you. The helper joins the workspace that person reaches its parent through, gets only its parent's tools and acts there as its parent does, so its job runs in their threads and every charge of it names them while your account pays. Before, the helper's job failed with "No such agent", and `POST /v1/agents/{id}/children` from their agent's turn was refused. Their own session still can't make one, a guest who reaches an agent only through a channel gets none, and a deleted agent no longer counts against a workspace's 200 members or shows among them.

[Read more in the guide](https://www.noclick.com/docs/guide/workspaces.md#members)

### Every charge says who it was for

New · Billing, SDK, API · Next SDK release

Every charge now records the person it was for: whoever's message, click or key started the work, through everything it starts (an agent's turn, the agents that turn asks, the wake-ups and routines it sets). Someone who joined one of your workspaces is named by their own login, a teammate's work in a team workspace is named for them while the team pays, and work nobody else started, your own users' included, is yours. `noclick.usage(group_by="person")` and `Usage.series(group_by="person")` split spend by it, each group with the person's `name` (`UsageGroup.name`), and Settings → Usage's Person split reads it. Charges from before keep their old split.

```python
for person in noclick.usage(group_by="person").groups:
    print(person.name, person.usd)
```

```ts
import { usage } from "noclick";

for (const person of (await usage({ groupBy: "person" })).groups) {
  console.log(person.name, person.usd);
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#who-each-charge-was-for)

### Use an account shared with your team in that team's workspace

New · SDK, API · Next SDK release

`Connection.list(organization_id=...)` (`organizationId` in TypeScript) reads in a team workspace you're in: an account a teammate shared with that team is listed there, with `access` `"view"` or `"edit"`, and only there. A connection read in a team workspace carries it (`organization_id`), and its runs, lookups and checks go there as the team's work; `Connection.from_id` and `Connection.get` take it too. Before, `/v1` never reached an account shared with a team. An agent's tools, `noclick.run` and calls `as_user` stay in your account's own workspace, and an app's code names no team workspace.

```python
team = "5c0d9e4a-7b1f-4e2a-9c3d-8f6b2a1e4d70"
for connection in noclick.Connection.list(organization_id=team):
    print(connection.name, connection.access)
```

```ts
import { Connection } from "noclick";

for (const connection of await Connection.list({ organizationId: "5c0d9e4a-7b1f-4e2a-9c3d-8f6b2a1e4d70" })) {
  console.log(connection.name, connection.access);
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#accounts-shared-with-a-team)

### Reconnect an account connected in the app with a link

New · SDK, API · Next SDK release

An account connected in the NoClick app (`credential:<id>`) takes a connect link now: `connect_link()` (`connectLink()` in TypeScript), or `request()` to send it. A key typed on the link goes back into that same credential, so every automation and agent using it keeps working, and one that was disconnected works again. The link's maker is the account's owner or someone it's shared with to edit; one shared with your account only to use raises `PermissionDenied`. Whoever opens the link types the key once, before it expires in seven days, and only the kind of key the account already holds. If the maker can no longer edit the account by then, nothing is written. A sign-in on the link runs as the app's own: the same account is reconnected, and another is connected beside it.

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#accounts-connected-in-the-app)

### An automation that uses a connection says what its steps are

Improved · SDK, API · Next SDK release

Each automation in a connection's `used_by` now carries `marks`: the node types its steps are (`["automation-gmail", "agent"]`), its triggers first, then its agents, then the rest, as many as four. They're what the app draws an automation by, so a page reading `used_by` can show each one as the app's Connections page does. Any other holder's `marks` is `null` in the API and empty in the TypeScript SDK.

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#delete)

### See who shared an account, whether its link works and what uses it; rename one

New · SDK, API · Next SDK release

An account connected in the app reads everything the app's Connections page shows of it. One shared with your account says how in `shared`: shared with your account's person or with the team workspace it's read in, and who shared it. A WhatsApp number or a Discord install reads its provider's live word on its session in `health`, with a `hint` saying what to do when it isn't working. `used_by` names the automations whose steps use a connection's account, beside the agents, MCP servers and apps it already named, and a delete's preview names them the same way. `verify()` returns the provider's whole answer: what its samples are (`noun`), how many there are (`total`), who the account signs in as (`account_label`), whether that proves the account or only that the key was accepted (`proves`), and a refusal in the provider's own words (`error`). An account makes at most 20 checks a minute, as the app's own check is held to. `rename()` changes the name an account connected in the app shows by; its owner renames it, or someone it's shared with to edit, and a named connection's name never changes.

```python
inbox = noclick.Connection.get("credential:9b2a1c5e-7d9f-4a31-8f6d-3f1d2c4b8a7e")
print(inbox.shared, inbox.health, [u["name"] for u in inbox.used_by if u["kind"] == "workflow"])
inbox.rename("Sales inbox")
```

```ts
import { Connection } from "noclick";

const inbox = await Connection.get("credential:9b2a1c5e-7d9f-4a31-8f6d-3f1d2c4b8a7e");
console.log(inbox.shared, inbox.health, inbox.usedBy.filter((u) => u.kind === "workflow").map((u) => u.name));
await inbox.rename("Sales inbox");
```

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#accounts-connected-in-the-app)

### Accounts signed in before an app's review are connections again

Fixed · Integrations, SDK, API · Next SDK release

An account signed in to Canva, Meta, Pipedrive, Threads or Zendesk before NoClick closed their sign-ins to new connections (while each provider reviews NoClick's app) is listed by `Connection.list()` as that app's connection again, and runs, takes the app's events and hands out its `token()`. Before, `/v1` named no integration for it, so it was missing from the list and its id found nothing. New connections to those apps still use the ways their integration's `credentials` list.

[Read more in the guide](https://www.noclick.com/docs/guide/connections.md#accounts-connected-in-the-app)

### Agents hearing an event no longer read a person's contact details

Fixed · Agents, API

An agent's trigger on a NoClick event and a channel's subscription read the event as it was: a person's answer to a call NoClick held for your account's owner (`human.answered`, `human.expired`) carried the owner's email and the call's arguments (a domain registrant's email, phone and address), the request's operation (`operation.*`) named its recipient, and a hand-off (`agent.conversation.handed_off`) carried the person's email and phone. Now what an agent or a channel reads of an event leaves out a person's contact details, as everything else an agent reads does, and keeps their name; so does a request's recipient read through NoClick's tools. Your webhooks and `noclick.Event.list()` still get every event whole.

[Read more in the guide](https://www.noclick.com/docs/guide/webhooks.md#your-agents-and-channels-hear-them-too)

### Hear each held call at your webhook, and answer it there

New · API, SDK · Next SDK release

Code that answers held calls with an `approvals:answer` key no longer has to poll `Approval.list()`. Two new event types: `approval.requested`, once as each call is held (one whose link reached nobody included), and `approval.decided`, once as it's approved, declined, expired or withdrawn (`data.status`), with who decided (`data.decided_by`, `data.decided_by_key`). Each event's `data` is the approval as `noclick.Approval` reads it, never its link: secret arguments read `[sealed]` and a person's contact details are left out. A call made for a user is heard by your account's endpoints and that user's, and an agent's own triggers never hear a call its own turn made.

```python
hook = noclick.Webhook.create("https://api.yourco.test/noclick/approvals", events=["approval.*"])
```

```ts
import { Webhook } from "noclick";

const hook = await Webhook.create("https://api.yourco.test/noclick/approvals", { events: ["approval.*"] });
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#hear-them-as-they-re-held)

## November 19, 2026

### Price an app before you make it, and copy a public repository

New · SDK · Python 0.2.2 · TypeScript 0.2.3

`estimate([...])` prices an app, a database, a bucket, a repo or live editing for a month before any of it exists: each charge comes back on a line of its own, with its unit, its price and how much of it a month, and nothing is made or charged by asking. `Repo.create(name, from_url=...)` (`fromUrl` in TypeScript) makes a repo as a copy of a public git repository, history and all; it returns the copy as it runs, and `wait()` gives the repo once it's copied.

```python
est = noclick.estimate([{"kind": "project", "usage": {"requests": 100_000}}, {"kind": "database"}, {"kind": "bucket"}])
print(f"${est.monthly_usd:.2f} a month")
blog = noclick.Repo.create("blog", from_url="https://github.com/acme/blog").wait()
```

```ts
import { estimate, Repo } from "noclick";

const est = await estimate([{ kind: "project", usage: { requests: 100_000 } }, { kind: "database" }, { kind: "bucket" }]);
console.log(`$${est.monthlyUsd.toFixed(2)} a month`);
const blog = await (await Repo.create("blog", { fromUrl: "https://github.com/acme/blog" })).wait();
```

#### Upgrade

`OnQueue` no longer takes `concurrency`. The API has refused it since 2026-11-15, when agents began taking one turn at a time, so drop the argument. For more throughput, raise `batch_size` (`batchSize` in TypeScript) or put several agents on the queue.

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#estimate-before-you-build)

### Every deploy checks its home page loads, as a visitor's browser would

Fixed · Apps, SDK · Next SDK release

Once a deployment goes live, NoClick now loads its home page whatever it runs, a site of files included: it must answer 2xx (a redirect on its own address is followed), and each script and stylesheet it names there must load as one. A 404, a 401, a redirect to a sign-in service that doesn't know the app's address, or a page whose script is answered with HTML (a build's base path set for another address) passed before, and the deploy read as working. It still goes live and its deploy still succeeds, but its result's `warning` says what answered and the new `next_step` (`deployment.next_step`, `nextStep` in TypeScript) what to fix. `noclick deploy` prints both and exits 1, MCP's `wait` leads with them, and a live session's end never points production at a release that fails it.

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#deploy)

### Answer held calls from your own code

New · SDK, API · Next SDK release

A purchase, a deletion that can't be undone or a raised limit that NoClick holds for your account's owner no longer has to wait for a person: your server can approve or decline it with one of your account's secret keys that names the new `approvals:answer` scope, through `noclick.Approval` (`list`, `approve`, `decline`) or `POST /v1/approvals/{id}/answer`. A key with every scope (`*`) doesn't hold it unless it's named too. A key never answers a call made with it, never approves one whose terms a person accepts (it may decline it), and approves only what it could make itself: the scopes the call needs, and what it approved this month within its own monthly cap, which also counts against what the key spends itself. While your account holds a key that would approve it, a call whose link reaches nobody is still held for your code (or the owner, signed in) to answer. Who decided is on the approval (`decided_by` is `code`, and `decided_by_key` names the key). `GET /v1/account` now lists the scopes a key holds only when they're named apart, in `meta.explicit_scopes`, so Full access built from `meta.scopes` never holds them.

```python
for approval in noclick.Approval.list(status="pending"):
    if approval.price and approval.price["amount_usd"] <= 20:
        approval.approve(note="Within budget.")
```

```ts
import { Approval } from "noclick";

for (const approval of await Approval.list({ status: "pending" })) {
  if (approval.price && Number(approval.price.amount_usd) <= 20) await approval.approve({ note: "Within budget." });
}
```

[Read more in the guide](https://www.noclick.com/docs/guide/policy.md#answer-held-calls-from-your-code)

### Show a browser live in your own page

New · SDK, API · Next SDK release

`browser.live_view()` (`liveView` in TypeScript) gives a single-use token for a websocket that sends the browser's page as it changes, for a page of your own: a tile with `thumb`, or, once you've taken the browser over, a view with `control` that also takes a person's taps, typing and keys. The token goes in the socket's first message, never its URL, and the view ends with the browser, at a hand-back, or when its key is revoked. In TypeScript, `browser.view()` asks for the token and opens the socket, again with a new token whenever it needs to, and sends a person's input only once the view shows the page. A driving view lasts as long as the take-over it was opened under. A browser has at most 8 views open at once and an account 20. A moment a view's access can't be checked keeps it open. Your account's keys and its signed-in owner get one; an MCP connection, an agent's turn and an app's code don't.

```python
browser.take_over()
view = browser.live_view(control=True)
send_to_page(view.url, view.token)
```

```ts
const view = browser.view({ thumb: true, onPicture: (jpeg) => show(new Blob([jpeg], { type: "image/jpeg" })) });
```

[Read more in the guide](https://www.noclick.com/docs/guide/browser.md#show-it-in-your-own-page)

### A browser's live page reaches only who may take it over

Fixed · API, Agents

A browser's `live_url` opens a page that drives it, with no sign-in, so it now comes back only to a caller that may take the browser over: your account's secret keys (one acting for a user too) and its signed-in owner. An MCP connection, an agent's turn (NoClick's assistant included) and an app's own code read it as `null`, as they could never take a browser over. Staff viewing an account in NoClick's support tools no longer take its browsers over or hand them back.

#### Upgrade

Code that showed `live_url` from an app's own code, or read it through MCP, now gets `null`: show a person the browser from your own server with a secret key, which still reads `live_url`, or read the page with `screenshot` and `content`.

[Read more in the guide](https://www.noclick.com/docs/guide/browser.md#watch-it-or-take-over)

### Only the person asked answers what grants an agent something

Fixed · Agents, API

A question NoClick asks before granting an agent something on a person's say (to run app testing, to pay with a card above its approval threshold, to switch to a paid model) is now answered only by the person it asks: from the link NoClick sent them, or by your account's owner signed in when it asks them. The agent that asked holds the question's id, and its page, opened by that id alone, answered it; now that page shows nothing, `HumanRequest.approve`, `decline` and their API route refuse it from any key with `PermissionDenied` (an app's code, a key in an agent's sandbox, a user's session), and `answerable="code"` leaves it out. The email or text NoClick sends carries the link that answers it, and that link's page now takes a choice or a Decline as the question's own form shows them.

Any request to your account's owner (`Human.owner()`) now has a page only at the link NoClick sends them (they also answer signed in): its id alone opens nothing, and its `url` reads `null` to your code. An owner who signed up by texting NoClick, with no email, now answers their requests signed in. Replying in, or handing back, a conversation handed to the owner also takes their link's key. A user's email, where NoClick sends the approvals that ask them, is changed only by a key acting for your account, and by an agent acting for it only once your owner approves. NoClick's staff viewing your account answer none of its requests.

#### Upgrade

Code that answered a card's purchase approval from a key or a user's session gets `PermissionDenied`: the card's user, or your account's owner for an account card, answers it from NoClick's email. Code that showed the owner a request's `url` gets `null`: NoClick already sends them its link. Code acting for a user (`as_user`, a key pinned to them, their session) that set their `email` gets `PermissionDenied`: set it with a key acting for your account.

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#answer-from-your-own-code)

### In a shared channel, only a person's own post lends an agent their permission

Fixed · Agents, API

A workspace's own NoClick acts for whoever posts, within their role. Five ways it, or an agent in one of your account's own channels, acted with a person's permission for words that person never wrote are closed:

- A turn that carries no person's own post (only an event's, a schedule's or an agent's) acts for no one: the workspace's NoClick reads it and tells whoever needs to know, and changes nothing. That holds for a turn it's owed for posts that arrived while it was busy.
- A workspace's NoClick works only in its own workspace. It joins no other workspace or channel (`noclick.InvalidRequest`), and a message, a question, a steer, a test run or a phone call sent straight to it raises `noclick.PermissionDenied`: post in one of its channels.
- A post an app's code, an MCP connection or an agent's turn makes `as` one of your users still lands in that user's name and wakes whom theirs would. It isn't their own word, so nothing acts with their permission for it.
- The same goes for a post made with a key or session that holds `channels` but not `agents`: it can't run an agent itself, so it lends no one's permission to one. Your account's own key posting `as` a user is that user's own post, as before.
- A guest can't have a workspace's NoClick save to the workspace's memory, which every turn of it reads. In a channel of your account's own, no agent writes its memory on a turn handed only words from outside your account's people (an app's event, an outside agent, a guest, a post code made in a person's or an agent's name). What an agent posts or starts on such a turn, and the message of a schedule set by an MCP connection or a key without `agents`, count as outside words too.
- A post without `as` made for one of your users (their session, a key pinned to them, your key naming them) is never your own word as the account's owner, and your account's NoClick can't be added to a user's channel.
- The child of an agent in a workspace reaches, through `everything`, the connections shared with that workspace, as its parent does.
- What an agent posts with its tools on a turn that acts for a person in a workspace is the agent's post, signed by it, as its reply is.

#### Upgrade

If your code messaged a workspace's NoClick directly (`Agent.send` on the agent `noclick-<workspace id>`), post in one of its workspace's channels instead.

[Read more in the guide](https://www.noclick.com/docs/guide/workspaces.md#its-own-noclick)

### An open terminal or shell ends when its access does

Improved · SDK, API, Agents · Next SDK release

A take-over's terminal, a sandbox's shell and a machine's shell are judged again every second while they're open. Each ends as soon as its key is revoked or expires or its user isn't active (code 4401), its agent or machine is deleted (4404), or, for a take-over, that take-over is handed back, even if someone takes it over again right away (4410). A token from one take-over opens nothing in the next. A moment the check can't be made keeps the session open; only 30 seconds of nothing but those closes it, with code 1011, to be opened again.

A client that says it renews (`"renew": true` in its first message) lasts 15 minutes at a time: in the minute before, the socket sends `{"type": "renew"}`, and an answer of `{"type": "renew", "token"}` with a new token for the same terminal keeps the session and its bash going. The TypeScript SDK's `connect` and `noclick machines ssh` renew for you; for a machine's shell in TypeScript, pass `renew` to `TerminalConnection`. A client that doesn't say so, like a terminal you wrote before today, has no such limit and needs no change.

[Read more in the guide](https://www.noclick.com/docs/guide/agents.md#take-over-its-terminal)

### A workflow says what it's made of, and a connection names its account

Improved · SDK, API · Next SDK release

Each workflow in `Workflow.list()` carries `step_types` (`stepTypes` in TypeScript): at most four of its step types, its triggers first, then its agents (`agent:codex` for one on a coding harness), then the rest, never a note. The list leaves out a workflow NoClick runs for itself, your assistant's, which still reads by its id. A connection's `account` now names the account it reaches as the app's Connections list does: its login, else its email, else who a check verified it as, else the number it links, where before it was only who a check verified it as.

```python
for workflow in noclick.Workflow.list():
    print(workflow.name, workflow.step_types)   # Morning brief ['trigger-cron', 'agent:codex']
```

```ts
import { Workflow } from "noclick";

for (const workflow of await Workflow.list()) console.log(workflow.name, workflow.stepTypes);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#find-workflows)

### A workflow's approval step waits 7 days, not forever

Improved · NoClick app, API

An approval step's question now expires 7 days after it's asked, as a connection's approval of a single call already did after 24 hours. Once it has, it's no longer listed as waiting, answering it says it expired, and the run that waited on it ends with an error saying why, so a run from code (`awaiting_human` until then) fails rather than waiting forever. Approvals that had been waiting longer than 7 days were closed the same way.

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#don-t-wait-on-it)

### Every number you hold is in the API, wherever you bought it

Improved · Phone, API, SDK · Next SDK release

`PhoneNumber.list()`, `GET /v1/phone_numbers` and the console now list every number you hold, including the ones bought in the NoClick app: in Resources, setting up a Phone step, on a purchase link or from a card in the chat, and ones whose order the carrier approved later. Each is your account's own number (no `user_id`, no `name` until you give it one), and it can do everything a number bought through the API can: answer with an agent, take calls only from the callers you choose and transfer them, and, where its carrier allows, text callers and move to another carrier. Prices and charges don't change.

A number deleted in the app, or given back because a month went unpaid past its grace, now goes the way `release()` does: it stops ringing and texting and leaves your list. Before, it stayed listed and could keep its agent's phone step. When its carrier can't take it back just then, `release()` raises `noclick.UpstreamError` and the number stays yours, as does one deleted in the app, which says why: give it back again in a few minutes.

[Read more in the guide](https://www.noclick.com/docs/guide/phone-numbers.md)

### Unpublishing through a build is judged as unpublishing the app

Fixed · API, Agents

A build of an automation that takes its app down (`workflow.unpublish()`, or `publish: {"action": "unpublish"}` on `POST /v1/workflows/{id}/builds`) now meets the same rule as the app's own `unpublish()`: through MCP it's a deletion, previewed first, that needs `delete` as well as `deploy`, and from a key, an agent's turn or NoClick's assistant it waits for the account's owner, who sees what the preview said and that it takes the page down for good. Before, it was a write that needed only `deploy`, so a connection that could never unpublish the app directly could do it through a build. Publishing and renaming the app are unchanged, and so is anything your own key or the signed-in owner calls outside MCP.

#### Upgrade

An agent or a connected app that unpublished through a build now previews it first with the `delete` tool (operation `workflows_builds_create`, with the same `workflow_id` and `publish`), then makes it with the confirm token; a connection needs the `delete` capability for it.

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#publish-its-app)

### Your account's own key finds NoClick's assistant, making it first

Improved · API, Agents

`GET /v1/agents?name=coordinator` with one of your account's own secret keys, sent without `NoClick-User`, now makes NoClick's assistant when the account doesn't have it yet, as its signed-in owner's lookup always has, so an app you build on a key can talk to it on an account whose owner never opened NoClick's chat. Making it is what signing in does: it picks up what NoClick already knew for the account, takes the owner's texts and calls to NoClick's numbers while no agent of yours answers them, and gets its email inbox. Two lookups at once make one. An account an AI agent signed up for itself gets it this way only once a person claims it. A key or session acting for one of your users, an MCP connection, an app's own code and an agent's turn only look it up, as before.

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#answer-the-owner-s-texts-and-calls-with-an-agent)

### Improvements and fixes

- Fixed: A purchase link, or the chat's card for a number, refused some numbers (a $1.15 one among them), saying the price had changed when it hadn't.

## November 18, 2026

### Your account's own key reads the account

New · API

`GET /v1/account` now answers one of your account's own secret keys, sent without `NoClick-User`, so a console or dashboard you build on a key can draw the account: its plan, balance and month of spend, how many of each thing it has (`counts`), its `limits` and `features`, its defaults and what the platform offers (`meta`). A key reads exactly these fields and nothing about the person who owns the account. Before, only the signed-in owner could call it. A key acting for one of your users, a session, an app's own code and an MCP connection are still refused with `403`, and changing the account is still its signed-in owner's.

[Read more in the guide](https://www.noclick.com/docs/guide/http-api.md#authenticate)

## November 16, 2026

### Machines can go on a second, cheaper host, and in India

New · Agents, SDK, API · Python 0.2.2 · TypeScript 0.2.3

Machines can run on a second host, Hetzner, in `eu` where it's available: cheaper than DigitalOcean at each size, with a smaller disk, and with an `xlarge` size (16 vCPUs, 32 GB) that only it sells. `Machine.sizes()` lists the sizes and hosts available to you, with each one's price. A new machine goes on the cheapest host with stock, and on DigitalOcean when that one has none, never above your `max_monthly_usd`: a dearer host raises `PriceExceeded` naming it and its price. `host` on `create` picks one; a machine's `host` says where it runs, for its life. `Machine.sizes()` lists each size's `hosts` with their regions, disk and price. A new region, `in` (India), places machines on DigitalOcean in Bangalore. A quote names the host that will place the machine, and its purchase places it there or is refused, so you pay what was quoted.

#### Upgrade

`Machine.sizes()` and `GET /v1/machines/sizes` give each size's cheapest available host as its `disk_gb` and `monthly_usd`: read `hosts` for the host your region gets. A resize on Hetzner keeps the machine's disk.

[Read more in the guide](https://www.noclick.com/docs/guide/machines.md#sizes-and-hosts)

### A memory entry keeps its earlier versions

New · Agents, SDK, API · Python 0.2.2 · TypeScript 0.2.3

Every save to a memory entry keeps the version it replaces, so a change the agent made, or yours, can be undone. `versions` lists an entry's versions newest first, each with who wrote it and when; `get_version` reads one in full; `restore` puts one back as a new version holding its content and description. An entry keeps its last 50 versions, on an agent's own memory and on a named memory alike, and a conversation's checkpoint keeps none.

```python
support = noclick.Agent.from_name("support")
print([v.version for v in support.memory.versions("refunds")])
support.memory.restore("refunds", 1)
```

```ts
import { Agent } from "noclick";

const support = Agent.fromName("support");
console.log((await support.memory.versions("refunds")).map((v) => v.version));
await support.memory.restore("refunds", 1);
```

[Read more in the guide](https://www.noclick.com/docs/guide/memory.md#undo-a-change)

### Machine sizes list what's worth buying now, size first

Improved · Agents, SDK, API · Python 0.2.2 · TypeScript 0.2.3

`Machine.sizes()` and `GET /v1/machines/sizes` list each size once, at its cheapest anywhere now: the `region` and `host` that price is from, its `disk_gb` and `monthly_usd` there, and `regions`, every region it can be bought in now, cheapest first. A size that can't be bought now is left out, and so is a size another one beats: one that can be bought with at least its vCPUs and memory for the same price or less. `region="eu"` lists them as bought in that region, and `include_dominated=True` lists every size with `available` and `dominated_by`. Stock is read at most a minute before, and afresh once a purchase finds a host out of stock. DigitalOcean's stock is read now as well as Hetzner's, so a quote no longer names a host that has run out. In the app, a new machine is picked size first, each size from its best price and one sold out everywhere greyed, then where it runs, cheapest first; the confirm names the host, and a host that runs out as Buy is pressed is quoted again in place, with nothing charged at a price that wasn't shown.

```python
size = noclick.Machine.sizes()[0]
box = noclick.Machine.create("support-box", size=size.name, region=size.region, host=size.host,
                             max_monthly_usd=size.monthly_usd)
```

```ts
import { Machine } from "noclick";

const [size] = await Machine.sizes();
const box = await Machine.create("support-box", { size: size.name, region: size.region!, host: size.host!, maxMonthlyUsd: size.monthlyUsd });
```

#### Upgrade

`disk_gb` and `monthly_usd` are the size's cheapest offer that can be bought now, in `region`, not the cheapest host's list price, and sizes that can't be bought or that another size beats are no longer listed: pass `include_dominated=True` for every size. `region` and `host` say where that price is; pass them to `create` to be charged it.

[Read more in the guide](https://www.noclick.com/docs/guide/machines.md#sizes-and-hosts)

## November 6, 2026

### Text from outside is marked as data in a tool result's structured part too

Improved · Agents, API

NoClick's MCP server marks text someone else wrote, such as an email to an inbox, a text or call to a number, a channel message, a file, a run's output or an agent's reply, as untrusted data, so the model reading it treats it as data and never as instructions. The mark was only in a result's text, and a client that shows its model only the result's structured part, as Claude Code does, got that text unmarked. The structured part now carries the same mark on each such text, in a tag the text can't close. What a model copies exactly stays plain: numbers, links, email addresses, times, ids and short tokens like a status.

#### Upgrade

Code that reads a tool result's `structuredContent` finds those texts inside the tag, a file's text included: leave the tag out before using it. Content declared base64 stays plain. The API's own answers to your code are unchanged.

[Read more in the guide](https://www.noclick.com/docs/guide/mcp.md#the-tools)

## November 5, 2026

### An app reads a bound secret's keys under their own names

Improved · Apps, API

A secret bound to an app now reaches it the way it reaches a sandbox or an agent's shell: a secret holding `TELEGRAM_BOT_TOKEN`, bound as `TELEGRAM`, is read as `TELEGRAM_BOT_TOKEN`. The binding's name is what `app.bindings()` lists it by, and each binding's `variables` names what the code reads. An app's environment holds a name once, so a key that another bound secret holds, or that another binding, the app's own secrets or settings or NoClick sets, is refused with `Conflict` when you bind it, naming the key and both sides. A secret can gain a key after it's bound, so a deployment that finds a clash fails with the same words.

#### Upgrade

An app that read `<BINDING>_<KEY>` reads `<KEY>` from its next deployment, and the old name is gone.

[Read more in the guide](https://www.noclick.com/docs/guide/secrets.md#when-names-clash)

## October 30, 2026

### Edit an app live, in the page its owner has open

New · Apps, SDK, API · SDK 0.2.2

Edit an app in a live session: its site runs from a dev server, and each change shows in the pages its owner has open within a second, swapped in place where the code allows, so a game keeps running and a form keeps what was typed. An app live editing can run has `live_editing` on from its first production release (`update(live_editing=False)` turns it off), and NoClick's coding agent edits it live. `app.live.start()` gives the link that opens the app in live mode, `exec` runs a command in the session (in the background for a long one, or a session's first) and says what each edit did in the open pages, and `end()` builds what changed, checks it where production serves, and deploys it only if both pass. It's for your account's own apps built with Vite, or of files with or without a worker, billed by the minute at what the container costs, about 5 cents an hour.

```python
app = noclick.Project.from_name("larkspur")
print(app.live.start().enter_url)
result = app.live.exec("sed -i 's/Score/Points/' src/render.js", background=True).wait()
print([edit.outcome for edit in result.vite])   # ['hot']
app.live.end().wait()
```

```ts
import { Project } from "noclick";

const app = Project.fromName("larkspur");
console.log((await app.live.start()).enterUrl);
const result = await (await app.live.exec("sed -i 's/Score/Points/' src/render.js", { background: true })).wait();
console.log(result.vite.map((edit) => edit.outcome));   // [ 'hot' ]
await (await app.live.end()).wait();
```

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#live-editing)

### Change a workflow step by step, and undo any change

New · SDK, API · SDK 0.2.2

A workflow is now a handle your code changes directly, as the app's canvas does, with no builder in between. `Workflow.graph()` reads its whole definition at the workflow's `version`: its name, description and settings, and every step with its settings as stored, its notes and edges, never a secret (each is named by its path in `withheld`, and writing a step back without it keeps it). Each change is one call on a `Step` (`update`, `patch`, `connect`, `set_connection`, `mock`, `remove`) or the workflow (`add_step`, `update`, `add_note`, `move`), judged as the builder judges one and applied at once; the step comes back as written, with whether it's ready to run (`verdict`) and what the change did on its own (`notes`). `Workflow.edit()` sends several changes as one batch that lands whole or not at all, and with `if_version` it's refused with `noclick.Conflict`, carrying the workflow as it stands, when someone changed it since you read it. Every change lands in the workflow's history: `versions()` lists who changed what from where, each version under a `history_version` that never changes (a change from your code is a version of its own, and a session in the app's canvas one version listing its `authors`), and `restore(history_version=...)` puts one back, name, description and settings with its steps, as a new version you can undo too. The workflow's read now carries its `version`, and leaves notes out of its steps. Over HTTP it's `GET /v1/workflows/{id}/graph`, `POST /v1/workflows/{id}/edits` and the `versions` routes.

```python
brief = noclick.Workflow.from_name("Morning brief")
graph = brief.graph()
with brief.edit(if_version=graph.version) as e:
    post = e.add_step("automation-slack", operation="send_message_to_channel", settings={"channel": "#team"})
    e.connect("summarize", post)
latest, before = brief.versions(limit=2)
brief.restore(history_version=before.history_version)   # and it's gone again
```

```ts
import { Workflow } from "noclick";

const brief = Workflow.fromName("Morning brief");
const graph = await brief.graph();
await brief.edit({ ifVersion: graph.version }, (e) => {
  const post = e.addStep("automation-slack", { operation: "send_message_to_channel", settings: { channel: "#team" } });
  e.connect("summarize", post);
});
const [, before] = await brief.versions({ limit: 2 });
await brief.restore({ historyVersion: before.historyVersion });   // and it's gone again
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md#change-it-step-by-step)

### A call held for the account's owner can be waited on

Fixed · SDK · SDK 0.2.2

A call NoClick holds for the account's owner (a purchase or a deletion that can't be undone, made by a deployed app's code, an agent or a connected app) raises `noclick.ApprovalRequired`, and its `operation` was `None`: only a policy's approval had one. It's now the held call itself. NoClick makes the call once the owner approves it from the link they were sent, so there's nothing to retry: `wait()` returns the call's HTTP `status` and its `response`, and raises `noclick.PolicyDenied` if they decline.

```python
try:
    noclick.Secret.from_name("stripe-live").delete()
except noclick.ApprovalRequired as held:
    print(held.operation.wait()["response"])
```

```ts
import { ApprovalRequired, HumanRequest, Secret } from "noclick";

try {
  await Secret.fromName("stripe-live").delete();
} catch (err) {
  if (!(err instanceof ApprovalRequired) || !err.operation || err.operation instanceof HumanRequest) throw err;
  console.log((await err.operation.wait()).response);
}
```

#### Upgrade

In TypeScript, `ApprovalRequired.operation` is now `HumanRequest<boolean> | Operation<JsonObject> | null`: check `instanceof HumanRequest` before reading a policy approval's `url` or `requestId`.

[Read more in the guide](https://www.noclick.com/docs/guide/errors.md#the-ones-you-ll-handle)

## October 29, 2026

### Follow a call while it's on, and hang it up

New · Phone, SDK, API · SDK 0.2.2

A call your agent places can be read while it goes: `PhoneNumber.get_call` takes the operation `number.call()` returned, or the call's id, and says whether the person picked up (`answered_at`) and what was said so far, turn by turn (`lines`). `PhoneNumber.hang_up` ends a call the number placed, ringing or live: the agent says goodbye, and the call ends as any call does, with `ended_by` `hang_up` and its operation settling with the transcript.

```python
number = noclick.PhoneNumber.from_name("front-desk")
op = number.call("+14155550100", goal="Ask whether the order shipped.")
print(noclick.PhoneNumber.get_call(op).lines)
noclick.PhoneNumber.hang_up(op)
```

```ts
import { PhoneNumber } from "noclick";

const number = PhoneNumber.fromName("front-desk");
const op = await number.call("+14155550100", { goal: "Ask whether the order shipped." });
console.log((await PhoneNumber.getCall(op)).lines);
await PhoneNumber.hangUp(op);
```

[Read more in the guide](https://www.noclick.com/docs/guide/phone-numbers.md#follow-a-call-and-hang-it-up)

### Make a resource once with allow_existing, and from_name never ignores an argument

Improved · SDK · SDK 0.2.2

`create(..., allow_existing=True)` makes a resource the first time and, when the name is taken, returns the one already there untouched, so an agent your code makes once keeps the edits someone makes in the app. Every `create` whose names are unique takes it: agents, connections, cards, channels in a workspace, inboxes, MCP servers, machines, apps, secrets, users, webhooks, workspaces, buckets, databases, dicts, queues, volumes, memories, repos and browser profiles.

`from_name` with fields is two steps, and the docs now say so: it gets the resource, then sets the fields you pass, every time it runs; one you leave out is never changed. `create_if_missing` only decides what happens when there's none: it's created, or `noclick.NotFound` is raised. Fields passed without `create_if_missing` used to be dropped; now they're set too, so `Agent.from_name("support", instructions=...)` changes the agent that's there. A machine's `max_monthly_usd` is set like its size. An argument `from_name` can't set on one that exists is now checked instead of dropped, with or without `create_if_missing`: an agent's `ttl_s` or `parent_id`, a machine's `region`, an inbox's `local_part` or `domain`, a connected number other than `connect=`, and a connection's `integration` or `credential_type` that differ from what's there raise `noclick.Conflict` naming the field and the value it has.

```python
support = noclick.Agent.create("support", instructions="You answer questions about our product.", allow_existing=True)
```

```ts
import { Agent } from "noclick";

const support = await Agent.create("support", { instructions: "You answer questions about our product.", allowExisting: true });
```

#### Upgrade

Code that passed `from_name` fields without `create_if_missing` now sets them on the resource it finds, where before they did nothing: leave them out to only look it up. A `from_name` that passes a machine's `max_monthly_usd` now sets that ceiling. Code that passed an argument `from_name` can't set, and differs from the resource's, now raises `noclick.Conflict`: pass the value the resource has, or leave the argument out.

[Read more in the guide](https://www.noclick.com/docs/guide/agents.md#what-from-name-sets)

## October 26, 2026

### A deploy asks your app's API, and says when its code never ran

Improved · Apps, SDK, API · SDK 0.2.2

An app's `check_paths` now take what a plain request must answer, `{"path": "/api/health", "status": 200}` (with `"json": True` for a JSON body), beside pages. A deploy of code asks them once it's live: `warning` says what answered wrong, and `code_unchecked` says when the app's static files answered every path, so its code never ran. `Deployment.check` asks them too, waits for a page its scripts draw (`wait_for`), signs in with `headers` or `cookies`, and with `review` has a model score the screenshots. A preview of an app whose previews keep their own data says what it writes to in `preview_data`, and a deployment's `serves` names each URL it answers.

```python
repo = noclick.Repo.from_name("booking")
app = noclick.Project.create("booking", repo=repo, check_paths=["/", {"path": "/api/health", "status": 200}])
deployment = app.deploy().wait()
print(deployment.warning or deployment.code_unchecked)
```

```ts
import { Project, Repo } from "noclick";

const repo = Repo.fromName("booking");
const app = await Project.create("booking", { repo, checkPaths: ["/", { path: "/api/health", status: 200 }] });
const deployment = await (await app.deploy()).wait();
console.log(deployment.warning ?? deployment.codeUnchecked);
```

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md#check-it-works)

### Improvements and fixes

- New: `agent.history` reads the newest messages of a long conversation (`limit`), and `history_page` reads it back a page at a time.
- New: `agent.withdraw_question` withdraws a question the agent asked your account's owner once it's answered another way, with a note the agent reads at its next turn.
- Improved: A log read's `delay_s` says how long a line can take to show, and a deployment's `logs` keeps one `level` or `environment`.
- Improved: `app.sign_in.enable(deploy=False)` sets up sign-in and commits its code without deploying it.

## October 21, 2026

### Long turns carry on by themselves

Improved · Agents, SDK, API · SDK 0.2.2

An `sdk` agent's turn stops at the first of its limits (30 steps, $1 or 15 minutes) and says what it did and what's left, never an error. One its steps end carries on by itself in a follow-up turn, up to 3 in a row, and `reply.ended_by` names the limit that ended a turn. A call repeated with the same arguments and the same result is stopped after the third time. `turn_limits` gives an agent that does long jobs more room.

```python
reply = noclick.Agent.from_name("builder").message("Build and ship a site for the bakery")
print(reply.ended_by)   # None, or "steps", "spend" or "time"
```

```ts
import { Agent } from "noclick";

const reply = await Agent.fromName("builder").message("Build and ship a site for the bakery");
console.log(reply.endedBy);   // null, or "steps", "spend" or "time"
```

[Read more in the guide](https://www.noclick.com/docs/guide/agents.md#how-far-a-turn-goes)

## October 19, 2026

### Memories that agents share

New · Agents, SDK, API · Python 0.2.1 · TypeScript 0.2.2

A memory is now an object of its own, with a name, that any number of agents can read: what every agent of your company should know, or what one agent learned that another needs. Attach it with `memories=`; it's read-only unless attached with `writable()`. Each agent still keeps a memory of its own.

```python
company = noclick.Memory.from_name("company", create_if_missing=True)
company.save("tone", "Warm, brief, no jargon.", description="How we write")

support = noclick.Agent.from_name("support", create_if_missing=True,
                                  instructions="Answer billing questions.", memories=[company])
```

```ts
import { Agent, Memory } from "noclick";

const company = Memory.fromName("company", { createIfMissing: true });
await company.save("tone", "Warm, brief, no jargon.", { description: "How we write" });

const support = Agent.fromName("support", {
  createIfMissing: true, instructions: "Answer billing questions.", memories: [company],
});
```

[Read more in the guide](https://www.noclick.com/docs/guide/memory.md#share-a-memory-between-agents)

### The TypeScript SDK offers what the Python SDK offers

Improved · SDK · TypeScript 0.2.2

The `noclick` npm package now covers everything the Python package does, reading the same responses: an agent's A2A card, a channel's budget and halt reason, `ExecResult.ok`, `ToolResult.approveUrl`, `usage()`, and more. Methods take Python's names in camelCase, so an example from either guide reads the same.

#### Upgrade

`Channel.addMember`, `removeMember` and `listen` are now `add`, `remove` and `stream`, as in Python, and `Toolkit.handleAnthropic` is `handle`. The old names still work and are marked deprecated. The input type `ChannelAuthor` named is now `ChannelPostAs`.

```ts
// Before
await channel.addMember(agent);
for await (const m of channel.listen()) handle(m);

// Now
await channel.add(agent);
for await (const m of channel.stream()) handle(m);
```

### One language menu for the docs

Improved · Docs, SDK

Every code block in the guide now comes in both languages. Choose Python or TypeScript in the menu in the top bar, or in a block's header, and every block on every page follows, install commands included. The reference reads in either language too, with the same pages and anchors: [Python](https://www.noclick.com/docs/reference/python.md) or [TypeScript](https://www.noclick.com/docs/reference/typescript.md).

### Anyone can email your assistant

Improved · NoClick app, Agents

Your assistant's email address used to take only your own mail. It now takes anyone's, so people and other agents can write to it. Mail from someone else never lands in your own thread with it: each sender's mail gets a conversation of its own.

## October 18, 2026

### A monthly spending cap for your whole account

New · Billing, API

Set what your account may spend in each billing period in Settings → Plan and billing. Once the period's spend reaches it, every call that costs money fails with `noclick.SpendCapExceeded`, its `scope` `"account"`, until the period resets. What you already have keeps renewing (numbers, domains, storage), and apps keep serving pages until the period reaches twice the cap. Only the account's owner sets or raises it.

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#your-account-s-monthly-cap)

### Invite a friend, get $2

New · NoClick app, Billing

Every account has its own invite link, under your balance in the sidebar. When someone you invite starts using NoClick, $2 is added to your balance.

## October 17, 2026

### A site's backend gets the full SDK

New · Apps, SDK

Code in an app's backend can now call the whole SDK and message your agents, signed in as its deployment, with no key to keep. It reads and writes only what it made itself, never another app's resources. Each app has a monthly budget, `budget_usd_per_month` ($10 unless you set another): once it's used, the app keeps serving pages and reading its data, while its paid calls fail with `noclick.SpendCapExceeded`.

[Read more in the guide](https://www.noclick.com/docs/guide/spend.md#when-an-app-reaches-a-cap)

### Usage shows every charge

Improved · NoClick app, Billing

Settings → Usage lists what your account was actually charged, in dollars, with a plain name for each charge, and drills down to what used it: which agent, app, number or automation.

## October 16, 2026

### Reversible by default: the trash and undo

New · API, SDK · Python 0.2.1 · TypeScript 0.2.2

Deleting an app, database, bucket, dict, queue, repo, volume, inbox or agent now moves it to the trash, where it stays restorable for 30 days. A write that can be taken back records how, so its operation can be undone. Only purging is permanent.

```python
item = noclick.Database.from_name("orders").delete()
print(item.kind, item.name, item.purge_after)   # database orders 2026-11-14 ...

item.restore()   # back under its name, every table and row with it
```

```ts
import { Database } from "noclick";

const item = await Database.fromName("orders").delete();
console.log(item.kind, item.name, item.purgeAfter);   // database orders 2026-11-14 ...

await item.restore();   // back under its name, every table and row with it
```

#### Upgrade

`delete()` on these resources now returns a `TrashItem`, and the name is free again at once, so code that deletes something to make it again under the same name keeps working.

[Read more in the guide](https://www.noclick.com/docs/guide/undo.md)

### Check a deployment before it's live

New · Apps, SDK · Python 0.2.1 · TypeScript 0.2.2

`Deployment.check` loads pages of a deployment in a browser and reports each one's status, load time, console errors and a screenshot. Give an app `check_paths` and a promote is checked where it serves before production switches: a failed check leaves production as it was. Every promote bookmarks the app's databases first, so undoing it restores them too.

```python
checked = preview.check(["/", "/book"]).wait()
for page in checked.paths:
    print(page.path, page.status, page.problem)
```

```ts
const checked = await (await preview.check(["/", "/book"])).wait();
for (const page of checked.paths) console.log(page.path, page.status, page.problem);
```

[Read more in the guide](https://www.noclick.com/docs/guide/apps.md)

### Each preview branch gets its own data

New · Apps

An app whose `preview_resources` is `branch` gives each preview branch its own copy of the databases, buckets, dicts and queues its code names, made at the branch's first write. Until then its reads reach production, read-only, so a branch that only reads makes nothing. Inside an app, `Database.from_name` finds the app's own database for the environment it runs in.

### Edge or container, decided per commit

Improved · Apps

An app's runtime is `auto` by default: each deployment reads the commit it builds and runs where it says. A wrangler config, a JavaScript framework or plain files run on the edge; a Dockerfile, or a server in another language, runs in a container. Set `edge` or `container` to pin it.

### Agents can't force-push your default branch

Improved · Agents, Apps

An agent's push is checked before it lands: the default branch only fast-forwards and can't be deleted. A branch an agent rewrites or deletes is kept for 30 days; list them with `Repo.backups` and make one a branch again with `Repo.restore_backup`.

## October 15, 2026

### Sign in with Google, Apple and Microsoft, with nothing to set up

New · Apps, SDK · Python 0.2.1 · TypeScript 0.2.0

`app.sign_in` commits sign-in code into an app's repo, with its users in the app's own database. Google, Apple and Microsoft now sign people in through NoClick, so they work as soon as the operation ends, with no client to register at the provider. GitHub still uses your own client.

```python
app = noclick.Project.from_name("booking")
setup = app.sign_in.enable(providers=["email", "google", "apple"]).wait()
print(setup.managed_providers)   # ['google', 'apple']
```

```ts
import { Project } from "noclick";

const app = Project.fromName("booking");
const setup = await (await app.signIn.enable(["email", "google", "apple"])).wait();
console.log(setup.managedProviders);   // ["google", "apple"]
```

[Read more in the guide](https://www.noclick.com/docs/guide/app-services.md#add-sign-in)

### Email addresses on domains you bought

New · Domains, Agents

Make an inbox at a domain you bought through NoClick and its mail records are set up at once; on a domain you connected, the inbox goes on a subdomain. Mail to the address reaches the agent you name.

```python
support = noclick.Agent.from_name("support-bot")
inbox = noclick.Inbox.create(local_part="help", domain="mail.acme.test", agent=support)
print(inbox.address)   # help@mail.acme.test
```

```ts
import { Agent, Inbox } from "noclick";

const support = Agent.fromName("support-bot");
const inbox = await Inbox.create({ localPart: "help", domain: "mail.acme.test", agent: support });
console.log(inbox.address);   // help@mail.acme.test
```

[Read more in the guide](https://www.noclick.com/docs/guide/inboxes.md)

### Your own texts and calls, answered by your agent

New · Agents, Phone

What you text NoClick's WhatsApp and iMessage numbers, or say when you call, goes to NoClick's assistant. `answer_with` sends it to an agent of yours instead: a text's reply goes back on the app you texted on, and on a call the reply is read aloud.

```python
owner = noclick.Human.owner()
owner.answer_with(assistant)
```

```ts
import { Human } from "noclick";

const owner = Human.owner();
await owner.answerWith(assistant);
```

[Read more in the guide](https://www.noclick.com/docs/guide/humans.md#answer-the-owner-s-texts-and-calls-with-an-agent)

### A repo's commit history

New · Apps, SDK

`Repo.commits` lists a branch's history, newest first, and each commit's page in Resources shows its changes, file by file.

## October 14, 2026

### Put a website on a domain you hold

New · Domains, NoClick app

From a domain's page in Resources, pick one of your websites to serve there. Each name says where it stands: registering, DNS, certificate, then live. A purchase that fails frees the names it was going to serve.

## October 12, 2026

### Build automations from a description

New · API, SDK · Python 0.2.1 · TypeScript 0.2.0

`Workflow.create` with `instructions` has NoClick's builder make the automation, as it does in the app. Change it the same way, by describing the change, and run, pause and publish it from your code.

```python
brief = noclick.Workflow.create(
    "Morning brief",
    instructions="Every weekday at 8, email me today's calendar and the unread emails that need a reply.",
)
result = brief.latest_build.wait(timeout=900)
print(result.summary)
```

```ts
import { Workflow } from "noclick";

const brief = await Workflow.create("Morning brief", {
  instructions: "Every weekday at 8, email me today's calendar and the unread emails that need a reply.",
});
const result = await brief.latestBuild!.wait({ timeoutS: 900 });
console.log(result.summary);
```

[Read more in the guide](https://www.noclick.com/docs/guide/workflows.md)

### Browse numbers on any balance; buy with $5 in it

Improved · Phone, Billing

Searching for phone numbers is open to every account. Buying one, like anything paid up front, needs $5 in your balance on any plan, in place of the Member plan. A quote, a purchase's first step, says so before anything is bought, with an offer of funds to add.

## October 10, 2026

### Phone numbers in more countries

New · Phone, SDK

Numbers are sold in every country our carrier covers, each priced by its own search. A country that asks who holds a number takes the holder's address with the purchase. One that asks for documents takes them as uploads, and the carrier's review can take a few days, so `buy` returns a `PhoneNumberOrder` rather than the number.

```python
holder = noclick.NumberHolder(name="Dana Ruiz", street="Keizersgracht 1", city="Amsterdam",
                              postal_code="1015 CJ", country="NL", phone="+31612345670")
noclick.PhoneNumber.buy(pick, max_monthly_usd=5, address=holder)
```

```ts
import { PhoneNumber, type NumberHolder } from "noclick";

const holder: NumberHolder = {
  name: "Dana Ruiz", street: "Keizersgracht 1", city: "Amsterdam",
  postalCode: "1015 CJ", country: "NL", phone: "+31612345670",
};
await PhoneNumber.buy(pick, { maxMonthlyUsd: 5, address: holder });
```

[Read more in the guide](https://www.noclick.com/docs/guide/phone-numbers.md#what-a-country-asks-first)

## October 7, 2026

### The API is open to every account

New · API

Every account, on every plan, can now make keys and call the API, the SDKs and the MCP server. Start with [Getting started](https://www.noclick.com/docs/guide/getting-started.md).

## October 5, 2026

### One `noclick` package

New · SDK · Python 0.2.1 · TypeScript 0.2.0

The SDK is one package in each language, `noclick` on PyPI and npm, for the whole platform. The bridge custom components use in NoClick interfaces is part of it, as `noclick/embed`; components inside an interface keep importing `@noclick/sdk`.

```bash python
pip install noclick
```

```bash typescript
npm install noclick
```

[Read more in the guide](https://www.noclick.com/docs/guide/getting-started.md)

## Earlier

- [September 2026](https://www.noclick.com/docs/changelog/2026-09.md): 86 changes
- [August 2026](https://www.noclick.com/docs/changelog/2026-08.md): 122 changes
- [July 2026](https://www.noclick.com/docs/changelog/2026-07.md): 112 changes
- [June 2026](https://www.noclick.com/docs/changelog/2026-06.md): 93 changes
- [May 2026](https://www.noclick.com/docs/changelog/2026-05.md): 44 changes
