How a project's work moves
From a plan to the result: the steps, the reviewer, the house style, the queue, the stages — and what Kuyun does when it is stuck. How a project starts — the questions, the kind of work, the brief, what is yours to do — is Starting a project; the overview is Projects.
How work actually moves
Once there is a plan, Kuyun works through it on its own, in the background, between your visits. A second model reviews what the first one wrote before it becomes a finding — deliberately a different model, because a reviewer sharing the writer's blind spots is not a reviewer. That reviewer also checks the plan itself before any of it runs. If it still objects after a couple of tries, the work goes ahead and the objection is kept on the record: its words sit on the plan itself, under the plan's heading, and the project's chat notes it in the "Kuyun worked" line. If the reviewer cannot be reached at all, the plan waits rather than starting unchecked, and Kuyun tries again by itself within the hour; after several tries it goes ahead, and the chat says it went ahead unreviewed.
Some reservations are Kuyun's own rather than the reviewer's — a plan whose shape it will not accept, or a part of the work it has no way to do yet, which the team is asked to look at. None of these needs anything from you. When Kuyun changes the plan on your behalf because a step was stuck, you get one notice saying so; everything else is in the project's chat when you look.
Later steps build on earlier ones: a step that refers to earlier work — "write the lessons to match the schedule and the vocabulary" — reads those earlier findings directly, rather than searching the web for them.
A project learns its own house style. When the work is material you read — lessons, chapters, days of an itinerary — Kuyun writes the first batch, has it checked, and then writes a short writing guide for the project: how a unit is built and in what order, how long it is, where the listening and the practice go, how the units are named, and what a unit never contains. From then on every later batch is written to the guide and checked against it, so what passed once keeps passing. The guide is a file in the project, beside the brief, and you can read it: ⚙ → How Kuyun writes this opens it (anyone working on the project with you finds it among the project's files). You do not edit it yourself. To change how the units are written from now on, say so in the project's chat: "put the answer key last", "shorter dialogues" — Kuyun edits the guide, and the change holds for everything written after; what is already written stays as it was. You can also give Kuyun your rules before anything is written, and it writes the guide from them; it never replaces that with one of its own. If you prefer, choose a stronger model for the first batch and the guide and a cheaper one for the rest, in the project's Models menu.
When what you want is something to read, the plan writes it. Lessons, chapters, the days of a trip: the steps that write them put each piece straight into the Content list as it is finished, a few pieces per step, so a course fills in while the plan runs — you do not have to ask for it. A long piece — a book chapter, a long lesson — is written in parts and appears once all of it is in, never half-written. Steps that only look things up still end in a finding, as before. What lands in Output is the pieces you asked for and nothing beside them: what a lesson needs — its sentences to hear, its word list, its answer key — is inside the lesson, what the whole course needs you told is in its README, and the rest of what a step learns stays in the step's own finding.
Doing the same thing to many pieces is one step. "Write every remaining lesson like the sample" is a single line on the plan, however many lessons it covers. Kuyun works through it a lesson or two at a time, and the reviewer checks each batch as it lands, so the step's line on the page shows how far it has got ("12/40 units"). If one piece keeps failing the review, Kuyun asks you about that piece and carries on with the rest, so one difficult lesson never holds up the others. Every step that writes pieces for you names them before it starts — never "the next few" — so it is done when each named piece is accepted, and the page can say how many are left. A piece a little longer or shorter than the writing guide's usual length is noted, not sent back; what sends it back is a length you set and it broke.
You do not have to approve each step. You will be asked when a real decision is needed, and told when something is done.
Kuyun keeps going. Once you have said yes to a piece of work, that yes covers all of it: ninety lessons means ninety, not a week at a time with a "say go" in between. Kuyun stops to ask you only for what only you can say (who the course is for, what you like), before anything that cannot be undone or that reaches other people, when it would change direction, and to show you the first sample of something new. For everything else it picks a sensible default, tells you in a line what it assumed, and carries on — correct it whenever you like.
A queue, worked to the end. Your projects form a queue: first any you chose Work on this first for, then the rest oldest first — the reverse of how your list shows them, which is newest first. Kuyun works the first ones that have something it can do — as many at once as your plan works, which Tokens's table gives — each step after step, until nothing in it can move — every step done, or the rest waiting on a check, on you, or on a briefing's daily hour — and then the next in line takes its place. A step the reviewer sent back is picked up again within a minute, not the next day. When a project is waiting its turn, its page says which project is ahead of it and that it starts when a place frees. To jump the queue, open the project's ⚙ menu and choose Work on this first, or say so in its chat or to the secretary — it moves to the head and the others keep their order. A watch keeps its own clock and is never queued.
Big jobs carry on by themselves. When a job is bigger than one reply — the rest of a course, say — Kuyun does a part, reports it, and keeps going without waiting for you. A line above the message box says "Kuyun is working on its own" and what is left, with a Stop button. Between parts, a second reviewer reads the new work against the sample you saw and decides what happens next: carry on; carry on later (when today's usage limit would run out, it picks the work up after the limit resets, and the line says when); stop and ask you something only you can decide; or stop because the work has drifted from what you approved, and say why. Each decision is a short line in the chat. Writing a message stops the work too — Kuyun reads yours next, with what was left in view. Research, and work that runs over days, goes into the plan instead, which runs without you.
A new plan is a new plan. When Kuyun re-plans — because you asked, or because a reviewer sent the work back — it writes the whole plan again from your brief rather than editing the old one around the edges. The steps are new, and none of them repeats something you have already finished.
The plan is Kuyun's to revise. There is no Regenerate button: when a step is stuck, Kuyun rewrites the plan around it on its own (below), and when you want the work to go another way, say so in the project's chat and it revises the plan the same way. Everything is kept either way: your files, your answers, the history, and the web pages Kuyun collected; work already done is moved into the new structure, not redone.
What was already written stays, unless it does not fit the kind of project — lessons with quizzes in a library, say, left by an earlier plan. The new plan then names a step that folds anything useful into the new shape and takes the rest out of the project's files — nothing disappears without a step that names it, and nothing you wrote yourself is taken off even if it does not fit. When a chapter is taken off, the people reading it lose their place in it, so a rewritten one starts from the beginning. If you own the project you can throw it all away instead: tick start over, and once the new plan is in place everything Kuyun wrote for the project is taken off the page and written again. Anything you wrote or edited yourself, your files and the history stay, and Kuyun asks first — saying how many people the project is shared with, since they start the rewritten chapters from the beginning.
While a plan is still being judged, its steps are shown. You can read them — that is the plan being judged — and the plan file says so. This is only ever the FIRST plan of a project: once one plan is in force, that is the one on the page, and a newer version being judged does not disturb it.
What you finished stays finished. Your completed work is kept separately from any one plan and listed above the steps — with what you reported about it, or Kuyun's own note where it was Kuyun that marked the step done — so re-planning never makes it look undone. You are not told each time the steps are rearranged — that is Kuyun changing its route, not the thing you asked for. You are told when what gets delivered to you changes.
When the work is done, Kuyun checks the result against your brief. Not each step against its own task — that happens as the work goes — but the whole of what came out against what you said you wanted. It runs by itself once every step that is Kuyun's is finished, and it ends in one of four ways. Whichever way, checking the result is then as far as the work has reached — laying it out and finishing up are the two steps that are still being built. The result is what you asked for, and the work moves on: it is not called finished while its Output holds nothing but the README — the findings and the summary kept beside Output are how the work was made, not the work delivered, so the plan is made again to file it there, once; if the new plan still delivers nothing, the project does not show as finished. When the result is there, Kuyun tells you in the project's chat — what you have and where it is — and, when the work can be published and is not yet, a 🌐 Publish it button under that message opens Publish (Sharing a project). The button is gone once it is published, and only you, its owner, see it. Particular steps fell short: those steps are un-ticked and done again, with the reason attached. The plan itself could never have produced it: Kuyun plans again from the brief, keeping what is already done. Or the brief itself got your goal wrong — then it asks you, with the answer it would assume if you say nothing. A project that never had a brief has none to get wrong, so there Kuyun plans again instead of asking.
You are not asked to approve any of this, and nothing waits on you. If the project's chat ever offers you a choice about whether to go on, the work is going on regardless; the only things that wait on you are your own steps and a question Kuyun could not answer for you. A step that comes back un-ticked is the one thing you would notice, and the reason is on the line that says it was sent back. A project that keeps a daily rhythm — a watch on a price, a morning briefing — is not checked this way yet: "done" means something different when the work is meant to go on, and that part is still being designed.
Ask where the work is. Kuyun works through seven steps, in order: understanding what you want, writing the brief, planning, doing the work, checking the result, laying it out for reading, and finishing up. The last two — laying out and finishing up — are still being built, so nothing reaches them yet. The project's chat knows which step the work is on, and every time it was sent back and why: ask it. Archiving a project does not mark it finished: the chat says where the work stopped, and the page says the project is archived and why. Someone you shared a course with is not told any of this — they get the reading, not the machinery.
When something was sent back to an earlier step, that is listed underneath: when it happened, who sent it back, and from where to where. A reviewer asking you a SECOND question about the same thing is listed there too — "asked again at" that step — because that is the same event from where you sit: you are being asked again, and the line says why. The mover is a reviewer, the clock, Kuyun itself, or you — asking for a plan while an earlier step is unfinished counts, so a line can say you sent your own work back. Where a reviewer sent it back, its reason is there in its own words; the other three move the work routinely, so there is no reason to read. Nothing in any of this is for you to act on. It is there so the answer to "why is it planning again?" is on the page rather than only in Kuyun's head.
When the tokens run out
A project's background work — research, lessons, reviews, summaries — is paid from its owner's tokens (Tokens), and once the day's allowance is used, from the owner's credit. When the owner has used today's allowance and has no credit left, the work pauses and the project page says Waiting for tokens; nothing is lost, and it resumes at the owner's midnight. Work that was already under way stops at its next step rather than running on, and that step starts again when the work resumes. Viewers' chats keep answering, since viewers pay for their own.
The work also pauses while its owner is away: 7 days without using Kuyun, on the Free plan (Tokens, "Background work waits while you are away"). Anyone who can edit the project with them sees only that it is paused, the same as for any other pause, and that it starts again by itself; only the owner sees why.
When you are stuck or it is
If a project asks you a question, answering it is usually the fastest way to unblock it. If a project has gone in a direction you did not want, say so in the project's chat — it changes the plan rather than starting over.
When a step's research keeps failing the reviewer's check, keeps failing to produce anything at all, or was asked for something no step of its kind can do, Kuyun does not turn that into a question for you. It treats it as its own problem: it rewrites the plan around the stuck step — the step split into smaller ones, replaced, or dropped, everything finished kept — checks the new plan the way it checks any plan, and carries on. None of this is a notification: the plan change is in the project's chat, in the "Kuyun worked" line, when you look. If the new plan cannot be made to work either, Kuyun stops trying for the day and the project's status says so — blocked, trying a new plan again tomorrow, nothing needed from you — while the team's tooling works out why; the step shows being refined meanwhile. If you archive the project while a step is being refined, it stops there.
When the work is finished, Kuyun's final check says the result meets the brief, and the producer tells you at once in the project's chat: what you have, where it is, and that nothing is needed from you unless you want changes. If you are not looking at the project just then, you get a notification too. It also suggests publishing the project (Sharing a project, "Publishing"): others get to use it, and a published project earns its owner credits.
There is one more way a project can go quiet on its own. Kuyun checks its own work, and the check can send the work back — to rewrite the plan, or to ask you something. When that keeps happening on the same project, Kuyun stops for the rest of the day rather than spending it going round: the project picks up the next day, and the project's chat can tell you what was sent back, and why. Your own changes never count towards that — send a plan back as often as you like.
The team's tooling can also find that the plan itself was at fault and send a plan change back; Kuyun applies it the same way, and the Creation Console notes it among Kuyun's own progress, in the "Kuyun worked" line described above: tap it to see Kuyun revised the plan, with the step that could not be done as written.
The same is true at the very beginning, before there is a plan at all. If Kuyun cannot get your brief into shape after a few tries, it stops rather than planning against a half-written one, and the whole project shows being refined with the same promise: nothing is needed from you, and it picks up again on its own once the team has looked — again, for as long as the project is running. It can happen later too, when a change to the brief cannot be written: the project says so in its chat rather than going quiet, and the team is told the same way.
Your project's details stay inside Kuyun while either of those happens; if the fix is a change to Kuyun's own code, the change goes to the team's code host with nothing about you or your project in it.