Przejdź do treści
Biblioteka skilli
Marketing i treści · Budowanie i kod

create-avatar

/create-avatar

Buduje awatara rozmownego Atmee albo cyfrowego bliźniaka: imię, zdjęcie, głos, postać i test, a także klip wideo z jednego zdjęcia.

Repozytorium
atmee-toolkit ↗
Licencja
MIT
Ostatnia zmiana repozytorium
11.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
48
Skrypty
4
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 11.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 4 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/contact-sheet.sh, scripts/media.sh, scripts/portrait-info.sh, scripts/upload-file.sh

Co robi i kiedy

Buduje awatara rozmownego Atmee albo cyfrowego bliźniaka: imię, zdjęcie, głos, postać i test, a także klip wideo z jednego zdjęcia.

Oryginalny opis (EN)

Build an Atmee talking avatar or digital twin - name, photo, voice, character, test - or a v2 video clip from a photo. Use when someone wants to make, continue or fix one. NOT for editing in Studio.

Jak działa

  1. How to ask the creator
  2. Rules that always apply
  3. The server
  4. Flow
  5. Copy an avatar
  6. Files and uploads
  7. References
Sekcje z nagłówków SKILL.md, w oryginale · 469 linii, 4 847 słów
Podgląd SKILL.md
---
name: create-avatar
description: Build an Atmee talking avatar or digital twin - name, photo, voice, character, test - or a v2 video clip from a photo. Use when someone wants to make, continue or fix one. NOT for editing in Studio.
license: Proprietary
metadata:
  owner: Atmanity
allowed-tools: Bash(*/scripts/media.sh *), Bash(*/scripts/update-check*), Bash(*/scripts/detect-host*), mcp__plugin_atmee_atmee-avatars__get_api_key, mcp__plugin_atmee_atmee-avatars__get_account, mcp__plugin_atmee_atmee-avatars__get_balance, mcp__plugin_atmee_atmee-avatars__list_avatars, mcp__plugin_atmee_atmee-avatars__get_avatar, mcp__plugin_atmee_atmee-avatars__create_avatar, mcp__plugin_atmee_atmee-avatars__update_avatar, mcp__plugin_atmee_atmee-avatars__duplicate_avatar, mcp__plugin_atmee_atmee-avatars__wait_for_avatar, mcp__plugin_atmee_atmee-avatars__list_candidates, mcp__plugin_atmee_atmee-avatars__add_candidates, mcp__plugin_atmee_atmee-avatars__select_candidate, mcp__plugin_atmee_atmee-avatars__create_upload, mcp__plugin_atmee_atmee-avatars__get_upload, mcp__plugin_atmee_atmee-avatars__wait_for_upload, mcp__plugin_atmee_atmee-avatars__replace_appearance, mcp__plugin_atmee_atmee-avatars__replace_voice, mcp__plugin_atmee_atmee-avatars__generate_portraits, mcp__plugin_atmee_atmee-avatars__enhance_portrait, mcp__plugin_atmee_atmee-avatars__design_voice, mcp__plugin_atmee_atmee-avatars__generate_clip, mcp__plugin_atmee_atmee-avatars__get_clip, mcp__atmee__get_api_key, mcp__atmee__get_account, mcp__atmee__get_balance, mcp__atmee__list_avatars, mcp__atmee__get_avatar, mcp__atmee__create_avatar, mcp__atmee__update_avatar, mcp__atmee__duplicate_avatar, mcp__atmee__wait_for_avatar, mcp__atmee__list_candidates, mcp__atmee__add_candidates, mcp__atmee__select_candidate, mcp__atmee__create_upload, mcp__atmee__get_upload, mcp__atmee__wait_for_upload, mcp__atmee__replace_appearance, mcp__atmee__replace_voice, mcp__atmee__generate_portraits, mcp__atmee__enhance_portrait, mcp__atmee__design_voice, mcp__atmee__generate_clip, mcp__atmee__get_clip
---

# Create an Atmee avatar

You help a creator go from a rough idea to a tested, live Atmee v2 avatar: a
portrait, a voice and a persona that talk in real time. The creator sees it
talk first: a name, a photo and a voice make the avatar, and its character
comes once the seed is on screen. The step that fails most is the portrait
and voice pair, so you check the inputs early, check the seed the server
picks, and save every step so nothing tried is lost. A seed is one short
talking clip the server makes from a portrait, a voice and the preview line;
this skill says seed, while the server says candidate (`list_candidates`,
`select_candidate`, `candidateId`) or take for the same clip, and the API's
`seed` field is an informational number, not the clip.

## How to ask the creator

Read this first. It is the rule rehearsals broke most.

**Every question to the creator goes through your question tool**
(`AskUserQuestion` in Claude Code), with one exception below. A question
whose answer is free text or a file goes through it too.

**The exception: what the creator must look at or listen to first.** When
you show portraits, voice samples or seeds to choose from, or give the test
link, end your turn with that content as your reply's text and a short
question in plain text, and call no question tool in that turn. The creator
answers in chat. A turn that goes straight from your thinking to the
question tool shows them neither the pictures nor the link: your thinking is
not your reply.

- One call per round: up to 4 questions that don't depend on each other, each
  with 2–4 short options.
- Your recommended option comes first, marked "(Recommended)". Word each
  question so that picking it means "yes, do what you recommend".
- **Free text** (a name, a line on who someone is, a look): offer your best
  guesses as options and say in the question what to type instead, because
  the tool's own "Type something" option is how they type it. "Who is Manny,
  in a line? Pick one or type your own" gets "A newsletter writer and founder
  in Taiwan (Recommended)". "What should Mira look like? Pick a style, or
  type age, gender, look and style" gets the styles. Never add an option such
  as "I'll describe it" or "I'll type it here": it duplicates "Type
  something" and costs the creator a second round. Never point to notes or a
  field the creator can't see.
- **Files:** "I'll drag them into the chat now (Recommended)" and "Go ahead
  without them". On the first, wait for the files.
- **Paid calls:** Yes and No, with the price and the balance in the question.
- The creator can always type their own answer, so never add an "Other"
  option or any other option that only means "let me type".
- **Never ask twice.** Before each round, drop every question the
  conversation, the creator's files or the avatar's iteration files already
  answer, including answers given in another form (a name typed in a free-text
  reply, a language implied by the files). If an earlier answer is unclear,
  state how you read it in one line and go on; the creator corrects you if
  needed.
- **Word options for what the creator sees.** Name the photo or file as it
  is ("Use the photo as it is"), never as a step you took ("the crop") unless
  you changed it.
- Never end your turn with a question written as plain chat text, and never
  paste a numbered list of questions to answer in one reply.

Without a question tool (claude.ai, some clients), ask the same round in chat,
in this shape, so the creator can answer by number:

```
1. <question>
   ➡️ <your recommended answer>
2. <question>
   ➡️ <your recommended answer>
```

## Rules that always apply

Read these before anything else, and keep them for the whole conversation.

1. **Ask once before each round of paid calls.** Where your agent honours this skill's
   pre-approved tools, the paid generation tools run without a permission prompt, so this
   question is the creator's only confirmation: never skip it. Before a round that costs credits
   (one paid call, or several at the same step, such as portraits and a voice), read each
   price from `get_account` (`pricing.generation`) and
   the balance from `get_balance` (rule 12), then ask one question with every
   call's price, the total and what the creator has left,
   for example "Make two portraits (<price>) and voice previews (<price>), <total> in all? You have <balance> left."
   Wait for a clear yes (ask it as a question with Yes and No options, rule 9), then pass
   `confirm: true` on each call in that round: the server refuses a paid call
   without it. A later round asks again. Each new paid request gets a fresh `requestId` (a UUID you make
   up). Retrying that same request with the same id is not a new call: don't
   ask again, keep `confirm: true`, and it won't charge twice.
2. **Generated portraits and voices go straight in.** Each comes back as
   `upload:<uploadId>`: pass it as it is to `create_avatar`,
   `replace_appearance` or `replace_voice`. Never download it and upload it
   again. Each one works for one avatar and expires 24 hours after it was
   made; its `url` is only for viewing, playing and saving a copy.
3. **Never** delete an avatar or start a paid session, and move credits only
   to sponsor an avatar when the creator asks and confirms. The creator tests the avatar on its own chat page (Step 4), not through you.
   Whenever anyone asks for a link to talk to the avatar, that chat page is
   the link: `links.chat` from `get_avatar` (`references/test-and-handover.md`,
   The avatar's links), not a LiveKit room from `start_session` or `session
   chat --open`; give a room only when they ask for LiveKit by name. Asked for
   another website page (its Studio page, Explore, billing, …), give the
   matching `links` field (the `atmee-product` skill's Website pages).
4. **Real people.** If the avatar is a real person other than the creator,
   confirm they have that person's permission right after the first opener,
   before any file, generation or create, keep
   the avatar private or unlisted, and never generate their face or design a
   voice to look or sound like them. Using a photo or voice sample of them that
   the creator supplies is fine once permission is confirmed. Save the answer
   in the iteration file. Details: `references/people-and-publishing.md`.
5. **Public only on request,** and only after the creator approves a title,
   description and tags you drafted (`references/people-and-publishing.md`).
6. **Talk in the creator's language.** The avatar's language is its own
   question, asked in step 1: the seed speaks it.
7. **Don't fake a judgment.** You can't hear audio, so the creator judges how a
   voice sounds. You judge lip sync only from a contact sheet you build
   yourself from the preview links; without one, say so and give the creator
   the links instead.
8. **Error codes decide retries.** From the paid generation tools:
   - `insufficient_credits`: say so, give the top-up link its message carries (or the billing page on atmee.ai), and don't retry.
   - `api_key_spend_cap_reached`: the API key's spend cap is used up; say so and don't retry.
   - `moderation_flagged`: nothing was charged; offer to rephrase.
   - `provider_failed`: nothing was charged; offer to try again (a new request).
   - `generation_unavailable`: generation is briefly unavailable or off; nothing was charged; offer to try again later.
   - `rate_limited` or `request_in_progress`: wait the time it gives (`retryAfter`), then retry with the same `requestId` and `confirm: true`. A wait of minutes can mean the charge is still being confirmed; the pending `paid_calls` entry keeps the id safe (`references/credits-and-generation.md`).
   - `invalid_input`: fix the input; don't repeat it unchanged. If it says the key was already used and charged and its result can't be recovered, tell the creator they were charged for a result that was lost, and ask before the new paid call it invites.

   From the other tools:
   - `account_ambiguous`: run setup's account question, then call again with the `accountId`.
   - `insufficient_v2_credits` (older servers that decide Atmee V2 by credits): a balance problem, not missing access. The part of the balance usable on Atmee V2 (`get_balance`'s `v2SpendableMicrocredits`) doesn't cover the call. Say so, and suggest Pro and up (every credit counts there) or ask whether they have an invite code: with one, redeem it as for `v2_access_required` below, and retry only once `v2SpendableMicrocredits` is above 0. Without either: offer engine v1 where the tool takes an engine. Never switch to v1 without asking.
   - `v2_access_required`: the account can't build Atmee V2 yet (building needs Pro and up; below Pro, an invite code unlocks it). Say so, suggest Pro and up (`get_account` `links.billing`), and ask whether they have an invite code. With one: call `redeem_code` with exactly what they typed, then read its `v2Access` (when the answer has none, call `get_account` and read its `v2Access` instead): retry the same call only when it is `granted`. `invite_required` means the code gave no v2 access (a credits-only code): tell them the credits it added (`microcreditsGranted` is in hundredths of a credit), that it is not a v2 invite, and ask for an invite code or offer v1; do not retry v2. Without one: offer engine v1. Never switch to v1, and never invent or reuse a code, without asking. `redeem_code`'s own refusals: `invalid_code` (check the spelling with them), `code_expired` or `code_fully_redeemed` (that code is spent: ask for another or offer v1), `already_redeemed` (this account used it before), `login_required` (an API key is connected: redeem in Creator Studio's Billing page instead).
   - `v2_pro_not_in_plan`: a V2 HD call on an existing V2 HD avatar this account may not rebuild. Say Atmee V2 HD is for Enterprise customers on custom plans, give the Studio help center to contact us (rule 13), and offer an Atmee V2 copy instead (an avatar's engine can't change in place: Copy an avatar, below); don't repeat the error's plan wording, and never switch without asking.
   - `engine_unavailable` on a V2 HD call: this server doesn't offer V2 HD right now. Say so and offer Atmee V2.
   - `rate_limited`: too many seeds are being made; wait the `Retry-After` it gives.
   - `avatar_busy`: a session is already live for this avatar; wait for it to end.
   - From `duplicate_avatar`: `source_file_missing` names a file of the source that can no longer be copied: replace that file on the source first (Files and uploads), then copy again. `avatar_limit_reached`: the account has as many avatars as its plan allows; say so and let the creator free one in Studio or upgrade (rule 3: never delete one yourself).
   - `preview_message_too_long`: shorten the preview line to 300 characters (code points) or fewer.

   **Two identical failures stop a retry,** on either server, paid or free:
   the same tool with the same inputs failing with the same error twice, or
   two batches in a row on the same portrait and voice where every seed
   fails, dies or looks weak. Change the input, coach the creator to another
   fix (`references/coaching.md`), or ask the creator; never try a third time
   unchanged.
9. **Ask with choices,** every time, as in "How to ask the creator" above,
   apart from its one exception.
10. **Talk about the avatar, not your work.** Tell the creator what happened
    and what comes next for them, in plain words: "Creating Manny now; it
    takes a few minutes." Keep your own checks, comparisons, retries, tool and
    file names, ids and server details out of the chat, unless something
    failed or they ask. A check that passed is not news: never say she
    "passed the content check", the "quality check" or "moderation", or that a
    build or stage completed; say what it means for the creator ("Her
    character is live"), and mention a check only when it found a problem. Never explain what a tool, command or page can't do,
    or why you're working around it: do the work, or say in plain words what
    the creator needs to do.
11. **Final steps wait for the creator.** The first seed of a face and voice
    goes live by itself, and so does the first seed after a new preview line,
    photo or voice (`references/coaching.md`, Fixes that rebuild). Switching to another seed (it goes live on the server)
    and making an avatar public happen only when the creator picks one or
    explicitly asks you to. Until then, recommend and wait.
12. **The balance comes only from `get_balance`:**
    `spendableMicrocredits` divided by 100 is the credits left; one kind of
    credit pays for every model. After a paid
    call, read `get_balance` again.
13. **Atmee V2 HD is for Enterprise customers only.** Never make a new V2 HD
    avatar or a portrait for one: never pass `engine: v2hd` (or `v2pro`) on a
    new avatar, whatever `get_account` reports (the V2 HD prices are there for every
    account and don't mean the creator can have it; `limits.v2Pro` is true only
    for an account allowed to create V2 HD, which only a copy relies on). The one exception is copying a V2 avatar onto V2 HD (Copy an
    avatar). Never offer it, quote a V2 HD price, or name a plan, upgrade or
    invite code as the way to it. When the creator asks for V2 HD, the HD
    model or the best model, say it is for Enterprise customers on custom
    plans, give the Studio help center to contact us (the origin of
    `get_account` `links.billing` plus `/studio/help-center`, for example
    `https://www.atmee.ai/studio/help-center`; with no `links`, name the
    Studio help center without a link, never a made-up address), and offer
    Atmee V2 instead. An existing V2 HD avatar keeps working: continue or fix
    it as this skill says.

## The server

One server does everything: `atmee-avatars` with the atmee plugin, `atmee`
without it. When `atmee-avatars/settings.json` has an `accountId`, pass it on
every call (setup saves it for a sign-in that belongs to several accounts).

- **Who and what:** who-am-I (`get_api_key`), the plan, prices and free
  capture slots (`get_account`), the credit balance (`get_balance`, the only
  source of it).
- **Avatars:** create, get, list and update avatars, copy one
  (`duplicate_avatar`, Copy an avatar below), replace the portrait, voice or
  knowledge, upload the creator's own files (`create_upload`,
  `get_upload`, `wait_for_upload`), list, capture and select v2 candidates.
- **Generation**, paid per call (`references/credits-and-generation.md`):

  | Tool | Use |
  |---|---|
  | `generate_portraits` | portrait options from a description, for an invented character |
  | `enhance_portrait` | cleaned-up square versions of a photo the creator gave, or with `prompt`, that person restyled ("as a 1920s detective") |
  | `design_voice` | voice previews from a description |
  | `generate_clip` | a short video (1 to 15 s, 480×480 up to 1280×720 or 720×1280, priced by size and length, charged at the next length up; 1080p coming soon) of a portrait moving as a prompt says, silent, or with sound from an audio file; no avatar is made |
  | `get_clip` | a clip's status by its `requestId`, free: follow a render after `request_in_progress` and get its download link |

  If the server lists none of them, or `get_account` has no
  `pricing.generation`, say generation isn't available and work with the
  creator's own files.
- **Sessions without video:** `start_speech_session`, `get_speech_session`
  and `end_speech_session` give a developer's client a speech-to-speech
  WebSocket. That is not how a person talks to the avatar: give them
  `links.chat`.
- **Sponsoring:** `grant_sponsor`, `update_sponsor` and `withdraw_sponsor`
  work signed in and need `confirm: true` after asking.

In claude.ai the server is a connector the creator adds; the atmee plugin
adds it for its agents; anywhere else setup adds it
(`references/setup.md`).

## Flow

The flow has five steps: **1 Name, photo and voice**, **2 The seed**, **3
The character**, **4 Test**, **5 Ready**. Use these names and numbers in chat,
so the creator always knows where they are and what is left.

### Start

1. Run the setup in `references/setup.md` (the same steps as the
   `atmee-setup` skill): it adds the atmee server if it is missing, checks
   sign-in, the account, credits and the local setup in one pass, then comes
   back here.
2. If `atmee-avatars/clips/pending.json` exists, retry that clip first, as
   Clips in `references/credits-and-generation.md` says.
3. If the creator only wants a short video clip, not an avatar, skip the
   rest of Start and the five steps: follow Clips there.
4. If `atmee-avatars/` exists in the project, list the saved avatars, skipping
   `clips`, and offer to continue one or start new
   (`references/iterations.md`, Resume). When the creator wants an existing
   avatar on Atmee V2, or a second one like it, copy it (Copy an avatar,
   below) instead of starting over.
5. For a new avatar, say in two lines how it goes, then start step 1:
   "Making an avatar takes 5 steps: **1 a name, a photo and a voice**, **2
   see it talk**, **3 give it a character**, **4 test it**, **5 hand it
   over**. Everything is saved as we go, so you can stop after any step."
   Begin each step with one line, "Step 2 of 5: see Mira talk".

### Showing results

Everything the creator reviews is shown here in chat. In an agent with a
shell, save every new portrait, voice sample and seed into the avatar's
folder with `scripts/media.sh save` (run by its full path from the project
folder). Server links expire, so save before showing. Then run
`scripts/media.sh show` once on the saved files. It prints a block per file
that suits where you run, and does any opening itself. Every block has a
`file://` link the creator clicks to open the file; in Claude Desktop's Code
tab it also shows a portrait inline, and opens the first voice sample or seed
in the creator's player without playing it (the chat can't play audio); the
others are links.

Give each option its own block in your reply: a heading with its file name
and a few words, the printed block unchanged, then its facts (any issue,
length, the lip verdict, your note). Mark your pick in its heading:

```markdown
### face_2 — short bob, freckles (Recommended)
![face_2.jpg](/Users/ana/project/atmee-avatars/mira-ab12cd34/media/faces/face_2.jpg)
[Open face_2.jpg](file:///Users/ana/project/atmee-avatars/mira-ab12cd34/media/faces/face_2.jpg)
Lips parted, face well inside the centre crop.
```

Never embed a server's https link instead: it expires, and Desktop hides
remote images behind a click. End the reply with the choice in plain text,
naming your pick and the other files, and call no question tool in that
turn (How to ask the creator, the exception): "Which face should Kai use?
face_2 is my pick; say face_1, face_3 or face_4 otherwise." The creator
answers in chat. `scripts/media.sh open` opens files in
the system viewer when the creator asks. Without a shell, give the server
links. If `media.sh save` refuses or fails on a link, show the server link
itself and say it expires.

Give `media.sh` the avatar's folder as `atmee-avatars/<folder>` from the
project folder, and name files by kind and number: `face_1`, `voice_1`, and
for seeds `seed_` plus the first 8 characters of the candidate id.

### Step 1: a name, a photo and a voice

Ask the two openers and then the name, language and files
(`references/drafting.md`, Step 1). If the avatar is a real person other than
the creator, apply rule 4 before anything else.

As soon as you know the avatar's name, make its folder
(`references/iterations.md`, Where). Save the creator's own portrait and
voice as soon as they give them; they are uploaded at the create ("Files and
uploads" below). Check each portrait as it arrives
(`references/portrait-checks.md`) and tell the creator about any problem.
When a portrait or voice is missing, offer to generate it, asking before each
paid call (`references/credits-and-generation.md`). Before the first paid
portrait call, generated or enhanced, settle the engine from `get_account`'s
`v2Access` and pass it on the call (the same reference, The engine a
portrait is for).

With a usable portrait and voice, create the avatar as v2 (never V2 HD,
rule 13; `references/candidates.md`, Model) with one seed that
goes live by itself, private, with no persona yet (`references/candidates.md`,
Create). Save the `create` iteration (`references/iterations.md`). Building
takes minutes: keep the creator posted in plain words
(`references/candidates.md`, Waiting), say once that each preview is a random
take (`references/coaching.md`, When to coach), and offer to start on its character
(step 3) while it builds: "While Mira's seed is made, shall we work on who
Mira is?" with "Yes, start now (Recommended)" and "I'll wait for the
seed".

### Step 2: see it talk

The first seed that finishes goes live by itself. Check it from the contact
sheet (`references/candidates.md`), show it ("Showing results" above) and
save a `candidate-selected` iteration once it serves. If the heads-up wasn't
said while it built, say it with the first take (`references/coaching.md`,
When to coach).

When its lips move weakly or not at all, or the creator says it looks off,
coach them through the fixes that match (`references/coaching.md`): another
seed, a livelier line, the photo or the voice. Switch seeds only on the
creator's choice (rule 11).

The avatar talks now but has no character yet: it answers as a plain
assistant. Unless step 3 is already under way, say so in one line, then ask
"Give <name> a character now?" with "Yes, now (Recommended)" and "Stop here,
continue later". On stop, save where you are; resuming picks up at step 3.

### Step 3: the character

Read what the creator gave you, ask the two character openers where the
material doesn't answer them, and draft the who prompt, what prompt (with what
it knows), greeting, self-introduction and guardrails
(`references/drafting.md`). Save it with `applied: no`. Sharpen it in up to
three grill layers if the creator wants (`references/grill-layers.md`).

Apply the character once the seed serves, and check that it is live before
going on (`references/drafting.md`, Apply the character). Mark the iteration
`applied: yes`. Knowledge never goes in
`knowledge.facts`: it lives in the what prompt, which can change any time.

### Step 4: test it

Write 3–5 in-character questions and end your turn with them and the
avatar's chat link as your reply's text, so the creator can click it, then
ask in plain text what drifted, with no question tool in that turn (How to
ask the creator, the exception). The creator talks to it, not you, so never
open the link yourself or say you'll test it
(`references/test-and-handover.md`). Then offer one refine round.

### Step 5: Ready

Hand over the chat link and the Studio link
(`references/test-and-handover.md`, Hand over). Clips are on every plan,
Free included, whatever `v2Access` says (don't check it for clips). When
`get_account`'s `limits.videoGeneration` is not false (absent
counts as allowed) and its `pricing.generation` has clip prices (`clipSizes`;
an older server: `clipPer15SecondsMicrocredits` or `clipPerSecondMicrocredits`),
add one line that Atmee can also make a short video clip from the same photo,
with sound when they give an audio file to play (a recording, or the voice
sample they gave) (Clips in
`references/credits-and-generation.md`), and make one only if the creator
asks. Without a clip price, say nothing about clips.

Never offer to commit or `git init`: the iteration files are saved either
way. Only when the creator asks, commit as `references/iterations.md`
(Commits) says.

## Copy an avatar

`duplicate_avatar` makes a new avatar from one of the creator's: nothing has
to be given again, and the source stays as it is. Copy when the creator
wants:

- **The same avatar on a newer model.** An avatar's model can't change in
  place, so an Atmee V1 avatar moves to Atmee V2 by a copy with
  `engine: v2`. It needs Atmee V2 on the account, checked as on a create
  (`references/candidates.md`, Create); `insufficient_v2_credits` and
  `v2_access_required` go as rule 8 says. Move an avatar once: first call
  `list_avatars` with `sort: updated` (any sort or filter returns the full
  rows) and read the source's `upgradedCopyId`. When it is set, the avatar
  already has a live V2 copy; point the creator to that one instead of
  making another, as Creator Studio does by hiding Upgrade to V2.
- **A second one like it,** to try another character or preview line while
  the original keeps serving: leave `engine` out, the copy keeps the model.

- **The same avatar on an older model,** when the creator asks for one
  (`engine: v1` for a V2 or V2 HD avatar, `engine: v2` for a V2 HD one).
  Say V1 works best with a front-facing, shoulders-up portrait; a half- or
  full-body V2 portrait may need replacing on the copy.

A copy keeps its frame shape: between V2 and V2 HD it takes the size
nearest the source's shape. Offer a V2 avatar's copy on V2 HD (`engine: v2hd`) only
when `get_account` shows the account can create V2 HD (`limits.v2Pro` is
true); otherwise keep it on V2. Never offer V2 HD for any other copy
(rule 13). Make a new avatar, not a copy, when the creator wants another
face or voice.

Before the call, tell the creator in two lines what the copy gets and
doesn't, and ask with Yes and No (rule 9). It spends no credits.

- **Copied:** the name (pass `name` to rename it; name it as Creator
  Studio does, so the two read apart in its list: "Mira (copy)" on the same
  model, "Mira (V2)" or "Mira (V2 HD)" on another),
  description, language, character (who and what prompts, alias, spoken
  name, other names, self-introduction, guardrails, conversational habits;
  the greeting only onto a V1 copy), preview line, knowledge (facts, answers
  and files), portrait and voice.
- **Not copied:** anything about sharing or money. The copy is private and
  not monetized, with no sponsor pool, Explore profile or thumbnail,
  statement or conductor; set those again only if the creator asks (rules 3
  and 5). A V2 copy doesn't take the source's seeds: it makes its own, in a
  few minutes, and a preview line over 300 characters is left out of it (it
  speaks the default line).

Then treat the copy as a new avatar: make its folder and save a `create`
iteration with the source's id (`references/iterations.md`), follow the build
(`references/candidates.md`, Waiting), and check its seed (step 2) before
the test (step 4). After a timeout or network error on the copy, list the
creator's avatars before trying again, as after a create.

## Files and uploads

- **The creator's own portrait, voice or documents** go to the avatars server,
  which keeps them.
  - **Save it first.** In an agent with a shell, tell the creator they can paste an image
    or drag any file (a photo, a voice recording, a document) straight into
    the chat; you receive its path. Never ask them to move files or type paths.
    Copy a file from chat into `atmee-avatars/<folder>/sources/` yourself.
  - **Upload it just before the call that uses it** (the create, a
    replace, or an enhance), never earlier: an upload works once and expires
    after an hour.
    Call `create_upload` with `kind` (`portrait`, `voice`, or `knowledge` for
    a v1 avatar's files), `fileName` and `contentType`. Declare the type
    `upload-file.sh` sends for the extension, because the upload takes only
    the declared one: its usual image or document type, `audio/mpeg` for mp3,
    `audio/mp4` for m4a, `audio/opus` for opus, `text/markdown` for md.
  - **With a shell,** from the project folder run this skill's
    `scripts/upload-file.sh` by its full path with the `uploadUrl` and the
    copy in `sources/`.
  - **Without one** (claude.ai, cloud sessions), give the creator the
    `uploadPageUrl` in a message: they choose the file there, or record a
    voice in the browser. The link works for 15 minutes; make a new upload if
    it lapses. In the same turn, right after that message, call
    `wait_for_upload`, and call it again while `status` stays `pending`, so
    the creator doesn't have to say it's done. If they seem away, end the
    turn and ask them to say when it's uploaded. A server without
    `wait_for_upload` takes `get_upload` instead.
  - **When the file arrives from the page,** tell the creator it's uploaded
    and ask whether to apply it now. Only after they agree, pass
    `upload:<uploadId>` where the create or replace takes a link. With a
    shell the creator already handed you the file, so don't ask again: once
    `get_upload` reads `uploaded`, pass `upload:<uploadId>`. Keep the upload id in the iteration file (`references/iterations.md`); never write
    `uploadUrl` or `uploadPageUrl` to any file.
- **Generated portraits and voices** are already uploads on the server: pass
  their `upload:<uploadId>` straight to the create or replace (rule 2).
- **No filesystem** (claude.ai chat): post the iteration record as a short
  summary in chat after each step instead of writing files.

## References

| File | Read when |
|---|---|
| `references/drafting.md` | asking the openers, drafting the character and applying it |
| `references/grill-layers.md` | running a grill round |
| `references/candidates.md` | creating the avatar, checking and fixing seeds |
| `references/coaching.md` | a seed looks weak, or the creator says a preview or conversation looks off |
| `references/credits-and-generation.md` | before any generation or paid call |
| `references/test-and-handover.md` | after a seed is selected |
| `references/people-and-publishing.md` | a real person is involved, or the creator wants it public |
| `references/iterations.md` | saving, committing, resuming |
Pliki w paczce (48)
  • SKILL.md 31 KB
  • agents/openai.yaml 1 KB
  • assets/atmee-icon.svg 1 KB
  • references/candidates.md 11 KB
  • references/coaching.md 8 KB
  • references/credits-and-generation.md 21 KB
  • references/drafting.md 9 KB
  • references/grill-layers.md 3 KB
  • references/iterations.md 7 KB
  • references/people-and-publishing.md 2 KB
  • references/portrait-checks.md 4 KB
  • references/setup.md 8 KB
  • references/test-and-handover.md 4 KB
  • references/negative-examples/ar-stickers.jpg 13 KB
  • references/negative-examples/backlit.jpg 5 KB
  • references/negative-examples/beard-over-lips.jpg 7 KB
  • references/negative-examples/blurry.jpg 7 KB
  • references/negative-examples/collage.jpg 15 KB
  • references/negative-examples/coloured-light.jpg 13 KB
  • references/negative-examples/eyes-away.jpg 7 KB
  • references/negative-examples/hair-over-face.jpg 14 KB
  • references/negative-examples/hand-over-mouth.jpg 14 KB
  • references/negative-examples/hat-shadow.jpg 7 KB
  • references/negative-examples/head-cut.jpg 9 KB
  • references/negative-examples/head-only.jpg 11 KB
  • references/negative-examples/heavy-compression.jpg 5 KB
  • references/negative-examples/laughing-mouth-wide.jpg 8 KB
  • references/negative-examples/low-resolution.jpg 9 KB
  • references/negative-examples/manifest.json 17 KB
  • references/negative-examples/microphone-at-mouth.jpg 12 KB
  • references/negative-examples/off-centre-landscape-cropped.jpg 2 KB
  • references/negative-examples/off-centre-landscape.jpg 4 KB
  • references/negative-examples/overexposed.jpg 9 KB
  • references/negative-examples/person-too-small-cropped.jpg 3 KB
  • references/negative-examples/person-too-small.jpg 2 KB
  • references/negative-examples/photo-of-screen.jpg 22 KB
  • references/negative-examples/second-face.jpg 10 KB
  • references/negative-examples/split-shadow.jpg 8 KB
  • references/negative-examples/sunglasses-glare.jpg 11 KB
  • references/negative-examples/tilted.jpg 12 KB
  • references/negative-examples/tongue-out.jpg 8 KB
  • scripts/contact-sheet.sh 3 KB
  • scripts/detect-host 1 KB
  • scripts/media.sh 8 KB
  • scripts/portrait-info.sh 2 KB
  • scripts/update-check 6 KB
  • scripts/upload-file.sh 3 KB
  • templates/iteration.md 2 KB

Wersje

W bazie nie ma innych skilli o nazwie create-avatar.

Migawka bazy z 13.11.2026 · wersja paczki 4f77dd7818b3 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100build-avatar-app
    Tworzy aplikację wokół awatara Atmee: sesje, dołączanie do rozmowy, stan aplikacji, zdarzenia, narzędzia i pliki.
  • 90atmee-product
    Opisuje funkcje, plany i ceny Atmee, czyli awatary wideo i klipy z jednego zdjęcia, bez ich tworzenia.
  • 100digital-human
    Tworzy i zarządza wideo z awatarami AI na podstawie gotowego lub własnego prezentera, dzięki czemu zmiana scenariusza nie wymaga ponownego nagrania.
  • 100heygen-avatar-video
    Produkuje wideo z awatarami HeyGen (Direct Video, Video Agent, Digital Twin, Avatar Realtime): dobór dostawcy, awatara i głosu, od skryptu do wideo, lip-sync z audio, tła, callbacki, zgody, kontrola jakości i rozwiązywanie problemów.
  • 100aicut-talking-avatar
    Sprawia, że osoba ze zdjęcia mówi podany skrypt za pomocą aicut CLI: najpierw lektor, potem wideo z synchronizacją ust, dla prezentera, rzecznika lub awatara AI.
  • 100digital-human
    Tworzy wideo z mówiącą postacią na podstawie skryptu lub audio i zapisanej postaci albo zdjęcia, np. do krótkiej wypowiedzi kamery.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.