What a Glyph is

Logic blocks and agent crews cover the large majority of real backend logic without writing infrastructure code. A Glyph is what's left over — the rare case where the logic genuinely needs a real programming language: recursion, a specific parsing algorithm, a third-party library's own implementation of something. It's still a stored, versioned, org-owned unit of code — not a one-off script you paste somewhere and forget.

Where you can call one from

Creating one

# Python Glyph — handler(request, ctx)
def handler(request, ctx):
    customer = ctx.app_db.get_entity("Customer", request["customerId"])
    ctx.log("looked up", customer["email"])
    return {"greeting": f"Hi {customer['name']}!"}

// JavaScript Glyph — module.exports.handler = (request, ctx) => {}
module.exports.handler = async (request, ctx) => {
  const customer = await ctx.app_db.getEntity("Customer", request.customerId);
  ctx.log("looked up", customer.email);
  return { greeting: `Hi ${customer.name}!` };
};

Sizes and limits

Every Glyph has a size, chosen in its Settings tab under Runtime size (or with size through MCP) and published with the rest of the version. Sizes your plan does not include appear greyed out with the plan that includes them and an Upgrade button; describe_glyph shows the same choices to an AI assistant. Glyphs saved before sizes existed are small.

A large Glyph is never run while a caller waits. Over HTTP, POST /app/{orgcode}/glyphs/{glyphId}/invoke answers 202 { jobId } and you poll GET /app/{orgcode}/jobs/{jobId} until it is completed or failed (the result is under result). A Logic Block can call one from a glyph step only when the block has Run in the background on. The Test tab, the MCP invoke_glyph tool and the crew glyph.invoke tool cannot wait for a large Glyph and answer glyph_background_only.

Each plan also limits how much you can run:

Compute is the memory in GB times the seconds a run takes, counted for failed runs too: a 2 GB Glyph that runs for 60 seconds uses 120 GB-seconds. Days and months are UTC. A run over a limit is refused with a 429 and an errorCode that names the limit (for example glyph_runs_per_day_limit_reached or glyph_compute_limit_reached); choosing a size your plan does not include is refused with glyph_size_not_in_plan (402). There is no overage billing. The MCP get_usage tool shows what you have used against these limits.

Draft, Active, and history

A Glyph is exactly two live records — draft (your working copy) and active (what actually runs) — not three things you manage yourself. Saving code only ever touches draft; Active never changes until you explicitly publish. Publishing copies draft's content into a new Active version and appends it to an unlimited, append-only history — nothing is ever deleted.

• The Versions tab's History section lists every past Active version, plus every draft save that actually changed the code (a no-op autosave is never logged, so the timeline stays meaningful).
• View, Compare, and Restore work on any past entry.
• Restoring is itself just another Activate — it creates a new version rather than rewriting history, so a restore can always be undone by restoring again. It also brings Draft back in sync with what you restored (the console warns first if you have unsaved draft changes, since those get overwritten).

Forking a system-owned Glyph

Some Glyphs are system-owned (shipped by the platform, not authored by your org). You can't edit one directly — fork it into your own org first, then edit and publish your own copy.