Changelog

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

NewAgentsSDKAPINext SDK release

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

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.

Read more in Machines
NewAgentsSDKAPINext SDK release

A memory entry keeps its earlier versions

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.

support = noclick.Agent.from_name("support")
print([v.version for v in support.memory.versions("refunds")])
support.memory.restore("refunds", 1)
Read more in Memory and files
ImprovedAgentsSDKAPINext SDK release

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

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.

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)
Read more in Machines

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

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.

Read more in The NoClick MCP server

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

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.

Read more in Secrets
NewAppsSDKAPINext SDK release

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

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.

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()
Read more in Apps and deployments
NewSDKAPINext SDK release

Change a workflow step by step, and undo any change

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.

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
Read more in Workflows
FixedSDKNext SDK release

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

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.

try:
    noclick.Secret.from_name("stripe-live").delete()
except noclick.ApprovalRequired as held:
    print(held.operation.wait()["response"])
Read more in Errors and retries
NewPhoneSDKAPINext SDK release

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

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.

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)
Read more in Phone numbers
ImprovedSDKNext SDK release

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

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.

support = noclick.Agent.create("support", instructions="You answer questions about our product.", allow_existing=True)
Read more in Agents
ImprovedAppsSDKAPINext SDK release

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

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.

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)
Read more in Apps and deployments
Improvements and fixes4
  • agent.history reads the newest messages of a long conversation (limit), and history_page reads it back a page at a time.

  • 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.

  • 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.

  • app.sign_in.enable(deploy=False) sets up sign-in and commits its code without deploying it.

ImprovedAgentsSDKAPINext SDK release

Long turns carry on by themselves

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.

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"
Read more in Agents
NewAgentsSDKAPINext SDK release

Memories that agents share

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.

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])
Read more in Memory and files
ImprovedSDKNext SDK release

The TypeScript SDK offers what the Python SDK offers

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.

One language menu for the docs

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 or TypeScript.

Anyone can email your assistant

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.

A monthly spending cap for your whole account

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 Spend and limits
NewAPISDKNext SDK release

Reversible by default: the trash and undo

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.

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
Read more in Undo and the trash
NewAppsSDKNext SDK release

Check a deployment before it's live

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.

checked = preview.check(["/", "/book"]).wait()
for page in checked.paths:
    print(page.path, page.status, page.problem)
Read more in Apps and deployments

Each preview branch gets its own data

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

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.

NewAppsSDKNext SDK release

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

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.

app = noclick.Project.from_name("booking")
setup = app.sign_in.enable(providers=["email", "google", "apple"]).wait()
print(setup.managed_providers)   # ['google', 'apple']
Read more in Email, payments and sign-in

Email addresses on domains you bought

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.

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
Read more in Inboxes
NewAPISDKNext SDK release

Build automations from a description

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.

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)
Read more in Workflows

Phone numbers in more countries

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.

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)
Read more in Phone numbers
NewSDKSDK 0.2.0

One noclick package

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.

pip install noclick
Read more in Getting started

Earlier