跑通了!让 WorkBuddy 免费 24 小时自主连续干活It Works: Running WorkBuddy Autonomously and Nonstop for Free, 24/7


AI free token/AI免费积分

跑通了!让 WorkBuddy 免费 24 小时自主连续干活

本文来源:https://www.163.com/dy/article/LC0BT8AE055616YL_pdya11y.html
若有版权问题,请来信告知:13951431913#139.com 或在右方提交评论。

先把结论放前面:我这台电脑上的 WorkBuddy(了解更多) 已经连着跑了 12 天 ,白天干活,夜里值守,闲的时候一分积分都不烧。

四个定时任务搭起来的,没花一分钱。积分怎么领,翻我前面写过的两篇,这篇只讲怎么让它连轴转。

下面是从零搭起来的顺序,照着抄就行。

第一版我只建了一个任务,每天早上七点派一次活。

它干完就停,下一单要等第二天。中间十几个小时,它什么都不干。

后来我想明白一件事: 连续不是靠一个任务跑得久,是靠几个任务接力。

有人干活,有人检查,有人派下一单,有人在旁边守着别断。四个角色凑齐,才像 24 小时有人值班。

我现在挂着的四个,名字、活、频率摆出来:

表 1:四个角色的分工。频率是按我这台机器写的,你按自己的活调。

四个角色怎么接力:干活收到巡检的结论,巡检看的是干活的产物,看门狗盯的是所有人的时点。示意图。

这里有个反常识的地方。四个任务里只有一个是真干活的,剩下三个都在管"干活这件事"。

有人会问,为什么不让一个任务自己循环。因为单个任务中途断了,没有第二个角色知道它断了。四个角色互为备份,断在哪一环,下一环能看出来。

二、主力干活任务:一天压两个时点就够

重活别撒在一天里到处跑。压在两三个时点,机器好调度,你也好查。

我设的是早上八点半、晚上七点半。早上那轮跑当天主线,晚上那轮补白天没做完的。

输入在哪。 别让它自己找,直接给路径。给目录它可能扫半天,给文件它一步到位。

输出写哪。 定死一个文件名,下一轮要读它。名字里带日期,省得覆盖。

做完回一句话。 干了什么、产物在哪、有没有剩下的。这句是给下一个任务看的,也是给你自己看的。

最容易漏的是第二条,输出路径没定死。 下一轮读不到,整条链接不上,前面白跑。

我的主力任务指令大概长这样,可以直接拿去改:

先读 tasks/today.json,那是今天的任务清单。 每做完一件,把结果写进 out/日期.json,键名跟清单里的 id 对上。 全部跑完,在 out/日期.done 写一行:完成几件、还剩几件、卡在哪件。 中途卡住不许重试超过两次,写清卡在哪就退出。

末尾那句很重要。不给它设次数上限,它会在一个死胡同里反复试,把你的积分全耗在那儿。

这个任务是整条链的中枢,也是最容易被写歪的一个。

歪在哪?很多人把它写成"再干一遍活"。它一动手,就跟主力任务抢时间,还会把产物覆盖掉。

三行字:看了什么、发现了什么、派了什么

每 2 小时 跑一次,正好接在主力任务后面。主力那轮干完,它隔一轮来看结果,看完把下一单放出去。

派单不靠"记住",靠写文件。任务之间没有记忆共享,只有文件共享。这一点想通了,多任务才搭得稳。

我那个派单文件写得很笨,不写给人看的话,只写机器要读的字段:

土办法有个好处:出问题你能一眼看懂。派错了也不怕,下一轮在派一单就是。

派单文件实样:一份真实交接文件的节选,字段名没改,值做了匿名,路径与账号已略。

四、模型守护任务:一个模型排队,整条链就停

主力干活和巡检都靠模型。模型一旦排队或者限流,任务不是"慢一点",是直接卡在那儿,等到超时。

所以我加了一个每 5 分钟探一次的守护任务。它只做三件事:探一下主力模型还通不通、不通就切到备用的那个、主力恢复了再切回来。

每 5 分钟 一次,比巡检密得多。因为它要保证的不是"活干得好",是"活能开始干"。

切回来这一步别省。一直挂在备用上,你会忘记主力是好的,长期跑下来质量会飘。

五、看门狗:空转零轮次,这才是免费的关键

前面三个都在干活,第四个专门管"要不要干"。

它每 5 分钟醒一次,进门先看队列。队列里没活,本轮直接结束,不调模型,不产一个字。

这个设计叫空转零轮次,是我这套东西能免费跑下去的真正原因。

24 小时挂着,不等于 24 小时在烧积分。有活的时候它起,没活的时候它连模型都不叫。

看门狗判断"有没有活"的办法更土:读一个队列文件,空了就退出。不用调模型判断,一个 if 就够。它不花钱,正是因为这一步不经过模型。

第二个作用是补位。万一某个任务卡死,它下一轮能看出来这个时点没产出,把这一单重新派出去。链子自己接上,不用你半夜起来按一下。

还有一件事得说:这台机器不能睡。笔记本合盖会休眠,一休眠所有定时任务全停。我是台式机常开,你要是用笔记本,把电源设置里的睡眠关掉,插着电跑。

先把来源说清楚:积分是每天领的,不是破解来的。

我前面写过两篇,一篇讲每天自动领 800 分,一篇讲怎么把月度额度领满。这一篇不重复,你翻回去看就行。

积分有了,接下来是别乱花。三个地方最费:

只让它判断和写结论,产物交给主力任务

按这个跑法,一天里真正调模型的时间不多,大部分时候机器在等。等的成本是零。

这段是我自己的运行记录,12 天没断过,数都是原样抄下来的。

24 小时操作分布:横轴 0 到 23 点,纵轴是当小时的操作条数。夜里那一段不是平的。柱状图,数据取自我这 12 天的记录。

不是演示,是挂着的。12 天下来,我这台机器上留下了这些数:

2,528 条 操作记录,从 0 点到 23 点, 24 个小时段每一个都有 记录。

夜里 0 点到 6 点的操作占了 三分之一 。那段时间我在睡觉。

这台机器上挂了 27 个计划任务,现在有 18 个时点在跑,最早 0 点 05 分那轮是守夜的,凌晨两点多还有一轮批处理,最晚 23 点 45 分收尾结算。

18 个时点怎么排的:时点和数量照抄我这台机器的计划任务,任务名匿名为功能类别。

这组数字说明的不是"AI 多能干",是 它在我不管的时候也一直在动 。四个任务的分工,撑住了这个连续性。这笔帐算下来,比我自己熬夜划算得多。

说清楚:这些数来自我这台机器,观察期 12 天,单机单账号,不是生产环境。积分怎么来,见前面那两篇。

第一步,先建干活的那个。 一天一个时点就够,输入输出写死,先让它单独跑通两天。

第二步,加巡检。 频率是干活任务的六倍。它只判断、只写结论,不许动产物。

第三步,加守护。 每 5 分钟探一次模型,切备用、切回来两步都要有。

第四步,加看门狗。 先判断有没有活,没活就退出。这一步不加,前面三个会空转烧积分。

第五步,第一周每天看一眼产出。 不看的话,你不知道它是真干完了还是写了一句"已完成"糊弄你。

还有一条经验:四个任务的时间别设成整点撞在一起。我的巡检和守护都错开了几分钟,不然同一时刻起四个,机器会喘。

手上有"每天都要做、但每次做起来差不多"的活的人。

写日报、跑数据、检查站点、整理文件都算第一类。特点是步骤固定,判断很少,做完就结束,交给定时任务最划算。

第三类别硬塞。四个任务能保证的是"不停",保证不了"做对"。做对还得你看一眼。

我下一篇想测:把巡检派单这层换成两个任务互查,看能不能把"看一眼"的频率从每天一次拉到三天一次。跑出来了再写。

你手上哪件活最想交给它?留言说一句,我挑一个真跑一遍再写出来。

It Works: Running WorkBuddy Autonomously and Nonstop for Free, 24/7

本文来源:https://www.163.com/dy/article/LC0BT8AE055616YL_pdya11y.html
若有版权问题,请来信告知:13951431913#139.com 或在右方提交评论。

It works! Let WorkBuddy(了解更多) work independently and continuously for 24 hours for free.

Let me get straight to the point: WorkBuddy on my computer has been running continuously for 12 days, working during the day and on standby at night. When it's idle, it doesn't use up a single point.

It's built with four scheduled tasks, and it didn't cost a single cent. For information on how to earn points, please refer to my two previous articles. This article only discusses how to keep the process running continuously.

Below is the sequence for building from scratch. Just follow it.

In the first version, I only created one task, which was assigned once every morning at 7:00 a.m.

It stops once it's done, and the next order has to wait until the next day. It does nothing for the intervening dozen or so hours.

Later, I realized something: Continuity doesn't come from sticking to one task for a long time, but from juggling several tasks in a relay-like fashion.

Some people work, some people inspect, some people assign the next order, and some people stand by to ensure there are no interruptions. Only when all four roles are present does it feel like someone is on duty 24 hours a day.

Here are the four I currently have, with their names, activities, and frequencies listed:

Table 1: Division of labor among the four roles. The frequency is based on my machine; adjust it according to your own workload.

How the four roles work together: The worker receives the inspection results, the inspector looks at the worker's output, and the watchdog monitors everyone's time points. Diagram.

There's something counterintuitive here. Out of the four tasks, only one involves actual work, while the other three are concerned with "the matter of doing the work."

Some may ask why not let a task loop on its own. Because if a single task is interrupted midway, no other role will know that it has been interrupted. The four roles serve as backups for each other. If one link breaks, the next link can detect it.

2. Main work tasks: It is sufficient to set two deadlines per day.

Don't spread out the heavy work throughout the day. Concentrate it at two or three time slots. It's easier to schedule the machines, and it's easier for you to check.

I set it for 8:30 a.m. and 7:30 p.m. The morning session is for the main quest of the day, and the evening session is for making up what wasn't completed during the day.

Where should I enter it? Don't let it search on its own; give it the path directly. If you give it a directory, it might take a long time to scan. If you give it a file, it will get the job done in one step.

Where to write the output. Fix a file name, and it will be read in the next round. Include the date in the name to avoid overwriting.

Leave a message after you're done. What was done, where are the deliverables, and is there anything left over? This sentence is for the next task, and also for you to see.

The second rule is the easiest to overlook, as the output path is not fixed. The next round can't be read, the entire link can't be established, and the previous work was for nothing.

My main task instructions look something like this, and you can directly take them and modify them:

First, read tasks/today.json, which is today's task list. After completing each task, write the result to out/date.json, with the key name matching the ID in the list. Once all tasks have been completed, write a line in out/date.done: how many tasks have been completed, how many are left, and which task is currently stuck. If you get stuck along the way, you are not allowed to retry more than twice. Specify where you got stuck and then exit.

The last sentence is very important. If you don't set a limit on the number of attempts, it will keep trying in a dead end and use up all your points there.

This task is central to the entire chain and is also the one most prone to being written incorrectly.

What's wrong with it? Many people write it as "do the work again." As soon as it starts, it competes for time with the main task and also overwrites the output.

Three lines: What was seen, what was discovered, what was sent

It runs every 2 hours, right after the main task. After the main task completes its round, it waits one round to check the results, and then releases the next order after reviewing them.

Task assignment doesn't rely on "remembering"; it relies on writing things down. There is no memory sharing between tasks, only file sharing. Once you understand this point, you can build a stable multitasking system.

My task assignment file is written in a very clumsy way. If it's not written for people to read, then only the fields that the machine needs to read are written:

There's one advantage to the traditional method: you can spot problems at a glance. Don't worry if you send the wrong one; just send another order in the next round.

Sample of order document: An excerpt from an actual handover document. The field names have not been changed, but the values have been anonymized, and the path and account number have been omitted.

4. Model Safeguarding Task: If one model is queued, the entire chain stops

The main work and inspections all rely on models. Once the model is queued or throttled, the task is not just "a little slower"; it gets stuck there and waits until it times out.

So, I added a watchdog task that checks every 5 minutes. It only does three things: check whether the main model is still working, switch to the backup model if it's not, and switch back to the main model once it's restored.

Every 5 minutes, much more frequently than inspections. Because what it needs to ensure is not "the work is done well," but "the work can begin."

Don't skip this step of switching back. If you always rely on the backup, you'll forget that the main one is good, and the quality will fluctuate over the long term.

5. Watchdog: Zero rounds of idling – this is the key to being free

The first three are all working, and the fourth one is specifically in charge of "whether to work or not."

It wakes up every 5 minutes and checks the queue first when it starts. If there are no tasks in the queue, this round ends immediately. The model is not called, and not a single word is generated.

This design is called "zero-round idling," and it's the real reason why my system can run for free.

Being online 24 hours a day doesn't mean you're burning points 24 hours a day. It starts up when there's work to do, and when there's no work, it doesn't even call up the model.

The watchdog's method of determining "whether there is work" is even more rudimentary: it reads a queue file and exits if it is empty. There's no need to use a model for judgment; an "if" statement is sufficient. It doesn't cost anything precisely because this step doesn't go through the model.

The second function is to fill in gaps. In the event that a task gets stuck, the system can detect the lack of output at that point in the next round and reassign the task. The chain connects itself, so you don't have to get up in the middle of the night to press a button.

One more thing: This computer can't go to sleep. When the laptop lid is closed, it goes into sleep mode, and all scheduled tasks stop when it goes into sleep mode. My desktop computer is usually on. If you're using a laptop, turn off the sleep function in the power settings and keep it plugged in.

Let's clarify the source first: Points are earned daily, not hacked.

I've written two articles before. One is about automatically earning 800 points every day, and the other is about how to max out your monthly allowance. This article won't repeat that information. You can go back and read those articles.

Now that you have the points, the next step is to avoid spending them carelessly. The three most expensive places:

Only let it make judgments and write conclusions, and hand over the output to the main task.

With this approach, there isn't much time spent actually tuning the model in a day. Most of the time, the machine is just waiting. The cost of waiting is zero.

This is my own running log. I ran for 12 days straight, and the numbers are copied as they are.

24-hour operation distribution: The horizontal axis represents 0 to 23 hours, and the vertical axis represents the number of operations in that hour. The section at night is not flat. Bar chart, with data taken from my records over the past 12 days.

It's not a demo; it's running. After 12 days, these numbers remained on my machine:

2,528 operation records, from 00:00 to 23:00, with records for each of the 24 time slots.

One-third of the operations take place between midnight and 6 a.m. I was asleep during that time.

There are 27 scheduled tasks on this machine, and 18 of them are currently running. The earliest one, at 00:05, is the night watch. There's another batch process at around 2:00 a.m., and the latest one, at 23:45, is the final settlement.

How the 18 time points are arranged: The time points and quantities are copied from the scheduled tasks on this machine, with the task names anonymized as function categories.

These numbers don't show "how capable AI is"; they show that it keeps working even when I'm not paying attention. The division of labor among the four tasks sustains this continuity. When I do the math, it's much more cost-effective than me staying up late myself.

To be clear: These numbers are from my machine, with an observation period of 12 days, a single machine and a single account, and not from a production environment. For how points are earned, see the previous two articles.

The first step is to build the one that does the work. One time point per day is enough. Hard-code the input and output, and let it run on its own for two days first.

Step 2: Add inspections. The frequency is six times that of the work task. It only makes judgments and writes conclusions, and is not allowed to modify the deliverables.

Step 3: Add protection. Probe the model every 5 minutes, and both the steps of switching to the backup and switching back must be included.

Step 4: Add a watchdog. First, determine whether there is any work to do. If there is none, exit. If this step is not added, the previous three steps will run idly and burn up points.

Step 5: Check the deliverables every day during the first week. If you don't check, you won't know whether the task is truly completed or if someone just wrote "Completed" to fool you.

Another tip: Don't set the times for all four tasks to start at the same hour. My patrol and guard tasks are staggered by a few minutes. Otherwise, if all four start at the same time, the machine will struggle.

People who have tasks that "need to be done every day, but are pretty much the same every time."

Writing daily reports, running data, checking sites, and organizing files all fall into the first category. The characteristics are that the steps are fixed, there is little need for judgment, and once completed, the task is finished. It is most cost-effective to assign it to a scheduled task.

The third category is "forced insertion." What the four tasks can guarantee is "non-stop," but not "doing it right." You still need to take a look to make sure it's done correctly.

For my next article, I want to test replacing the inspection dispatch layer with two tasks that check each other, to see if we can reduce the frequency of "quick checks" from once a day to once every three days. I'll write more after I've tried it out.

Which task would you most like to hand over to it? Leave a comment. I'll pick one, actually do it, and then write about it.

暂无评论,快来发表第一条评论吧!No comments yet. Be the first!

📮 需求咨询📮 Inquiry