LogiShell docs Open app

Get an agent's report as a link

An agent finishes a piece of work, and the result is something to read: a report, a spec, acceptance criteria, a plan. Without a place for it, that text ends up pasted into a chat, buried in a ticket, or published on some outside service. One more place where your work lives.

An artifact is that document kept in your LogiShell account, with a direct address:

https://app.logishell.com/artifact/<id>

You open it on a laptop or a phone, signed in as yourself, and see the title and the rendered document. It belongs to your account, not to a repository, so no project and no machine has to be open.

Ask for it in words

With the MCP door connected, you do not call anything yourself. Say what you want:

Put the report into an artifact and give me the link.

The agent calls artifact_create and answers with the address. Later, "fix the second section in that artifact" makes it call artifact_update: the address stays the same and the earlier text is kept as a version.

What the agent calls

Four tools, all on the personal door (https://mcp.logishell.com/mcp):

ToolWhat it does
artifact_createsaves a new document and returns its address
artifact_updatewrites a new version under the same address
artifact_readreturns one document in full, or one of its earlier versions
artifact_listlists your documents, newest first, without bodies

Creating one:

{
  "name": "artifact_create",
  "arguments": {
    "title": "Migration report, 12 October",
    "format": "markdown",
    "body": "# Migration report\n\nWhat moved, what did not, what is left.",
    "agent": "claude-code"
  }
}

The answer:

{
  "created": true,
  "artifact": {
    "id": "<id>",
    "title": "Migration report, 12 October",
    "format": "markdown",
    "version": 1,
    "size": 59,
    "url": "https://app.logishell.com/artifact/<id>",
    "agent": "claude-code",
    "createdAt": "2026-10-12T17:00:00.000Z",
    "updatedAt": "2026-10-12T17:00:00.000Z"
  },
  "note": "<a reminder that only the owner can open the link>"
}

artifact.url is what the agent hands you. agent and session are optional signatures: when given, they show up in the version history, so you can tell which session wrote which version.

Every call to artifact_create makes a new document. An agent that may be repeating itself should look at artifact_list first and update the document that is already there.

Changing one:

{
  "name": "artifact_update",
  "arguments": {
    "id": "<id>",
    "body": "# Migration report\n\nEverything moved. Two things are left.",
    "baseVersion": 1
  }
}

An update is an edit, not a rewrite. Fields you do not name stay as they are, so fixing a title does not need the body again. The id can be the id itself or the whole address.

Formats

formatHow the page shows it
markdown (default)rendered: headings, lists, tables, code
htmlrendered inside a sandbox, isolated from the app around it
textshown as written

Nothing guesses the format from the content. If the agent does not name one, it is markdown.

Limits

Versions

Every update keeps the text it replaced. The page shows which version you are reading and lets you pick an earlier one; artifact_read takes version for the same purpose. The current version and the last 50 earlier ones are kept. Older ones are dropped, and asking for one says so.

Two sessions editing the same document do not silently overwrite each other. An update that carries baseVersion (the version the agent read) is refused when the document has moved on since:

This artifact changed in the meantime: it is at version 3 now. Read it again
and re-apply your change; nothing was saved.

Over HTTP that refusal is status 409. The cure is in the sentence: read again, apply the change to the current text, send it again.

Who can open it

Only you. The address is not a secret that unlocks the page: it works under your sign-in and for nobody else. Another account that opens the same address gets the same answer as for an address that does not exist, so the link does not even confirm that a document is there.

That is the difference from sharing a page by link, where a file from your project gets a public address anyone can read. An artifact is the private one. Do not send its address to a colleague and expect them to see it.

A guest of an organization gets the read tools only and cannot write artifacts.

Over HTTP

The same door is /api/artifact-docs on the app, described with its gate on the API page. It accepts the browser session of a signed-in person, or the owner machine token of a deployment you run yourself. There is no personal API token for the hosted app: an agent reaches your account through the MCP door, which signs you in with OAuth.

On your own deployment:

curl -sS -X POST 'https://<your app host>/api/artifact-docs' \
  -H 'Authorization: Bearer <APP_M2M_TOKEN>' \
  -H 'content-type: application/json' \
  -d '{"title":"Migration report","format":"markdown","body":"# Migration report\n\nWhat moved."}'

It answers 201 with a doc object: id, title, format, version, size, createdAt, updatedAt and url, the address to hand to a person.

RequestWhat it does
GET /api/artifact-docs?limit=50your documents, newest first, no bodies; up to 200 per call, and more: true when older ones did not fit
POST /api/artifact-docscreate: title, body, optional format, agent, session
GET /api/artifact-docs/<id>one document in full, plus the list of kept versions
GET /api/artifact-docs/<id>?version=2an earlier version
PUT /api/artifact-docs/<id>a new version: any of title, body, format, plus optional baseVersion

Refusals carry error and message and a status that means what it says: 400 for a malformed request, 404 for a document that is not in this account, 409 for a stale edit, 413 for a body over the ceiling.

What is not here yet