Skip to content

Releases

Leaf Bot 0.8.0

Choose a tag to compare

@github-actions github-actions released this 22 Nov 11:57

Added

  • A routine can start when a row of its bot's table is ready, so a table works as a list of jobs the bot picks up.
    In the routine window, choose the table and, if you like, which rows (for example Status=todo). A row starts the
    routine once, with that row, the first time it has something in it and meets the conditions: when you fill in a row
    you added, or change one, say by setting its status. Rows the bot writes never start it, so a run that fills the
    table cannot start itself again, and neither do changes other people make. A row with cells the bot or someone else
    wrote is read as possibly holding outside text, so its run changes nothing without asking. A row that comes while
    a run is going waits for it instead of being dropped.
  • Follow-ups: the bot's own calendar, kept apart from the routines. A routine is the person's standing job, shown in
    the bot's list and set up by them or on their yes; a follow-up is the bot keeping track ("on Sunday morning, bring
    up Monday's visit"). After each turn whose words or answer name a day or a time, one call to the small model reads
    them beside what is already kept and adds what is coming up for the person (a visit, a meeting, a deadline, a
    delivery, a payment), moves what was put off and drops what was called off, wherever the bot learned it: in the
    chat, in a mail it read, in a routine's report. Bots can also add one themselves. Nobody is asked, and nothing shows
    among the routines; asked, a bot lists what it keeps track of and drops what the person does not want.
  • A follow-up is the person's: the same thing learned by two bots, or from two mails, is kept once. The server, not the
    model, picks when to bring it up: the morning before at the person's reminder time, else that morning, else two
    hours before, always in the day and before the thing; with no time left, not at all when the person is talking
    about it right then, otherwise as soon as it is day. When it comes up the bot that learned it gets a turn in its
    conversation with the person, reads the related mail again, looks whether the calendar has it and tells them with
    the context, offering to add it or to prepare. That turn works for nobody who asked just now and carries the mark
    of a mail it came from, so it sends, adds or changes nothing without a card: a planted mail can at most have the bot
    bring something up. Nothing still ahead is dropped because it could not come up in time: a paused bot or a spent
    limit makes it wait, a night makes it wait for the morning, and when its bot is gone the bot the person last wrote
    to tells them. It is dropped only once the thing itself is over. A follow-up reaches the person in Telegram and
    WhatsApp too, as a routine's report does, wherever they last wrote from.
  • The memory is tidied once a week. Bots write notes one conversation at a time, so the same fact ends up in several
    notes and an old note stays beside the newer one that contradicts it. Each set of notes that changed since it was
    last looked at (a bot's own, a person's notes about themselves, a place's) is read whole with one call to the small
    model of the bot that wrote them: notes that repeat are merged, of two that disagree the newer one or the person's
    own stays, and plans whose date has plainly passed are deleted. Notes the person wrote or pinned are read but never
    changed, a merge never joins notes about different sites or true until different dates, and one pass deletes at most
    about a third of a set. Every change shows in the memory history as the weekly tidy-up's.
  • The tidy-up also reads a note that came from a page against the page as it is now, once a month per note and at most
    ten pages a pass, a week after the note was written. When the page now plainly says otherwise about the same thing
    (a new price, date or address), the note gets its new value in about as many words and keeps its page; a page that
    cannot be read or says nothing clear leaves the note as it was. Pages are read by the server over https, never on
    this computer or the private network, and only for bots allowed on the internet.
  • Skill suggestions. Every turn now keeps a short list of the steps it took, secrets taken out. Once a week the
    many-step tasks a person asked a bot for over the last weeks are grouped; a kind of task asked at least three times
    on two days, done in three or more working steps each time and covered by none of the bot's skills, is written up as
    a skill by one call to the bot's small model, from the steps that worked and what the person wrote right after the
    answer. Today shows it with its name, description and instructions to edit; "Add skill" makes it and turns it on for
    the bot, "Not this" closes it for good. Only someone who may change the bot can add it.
  • The usage page shows what the memory tidy-up and the skill suggestions spent on their calls over the period, beside
    the other background checks: the sets of notes and source pages read and the notes changed, and the tasks written
    into skills and the suggestions made. A bot picked above narrows them to the calls on its account.

Changed

  • Promises no longer wait for the person. The Promises list on Today, with its "Done" and "Drop", and the line under a
    reply that made a promise are gone: a promise is the bot's to keep, not the person's to close. A bot's promise goes
    into its own calendar; one that waits for something ("when the result comes") is looked at the next morning, and
    the bot sets the next look itself while it still waits, telling the person once if a week goes by. A follow-up
    with nothing new to say (the bot already gave the result, or the thing is done) leaves nothing in the conversation.
    A person's own promise to someone else is brought up on its day, with nothing to close afterwards.
  • The reminders of a person's promises, of a bot's own promises and of the tasks in approved meeting minutes are
    follow-ups instead of one-time routines, so they no longer fill the bot's list of routines, and a person who may
    only talk with the bot gets them too. Bots are told to keep something to bring up later as a follow-up, not a
    routine. Reminders set before keep running as the routines they are.
  • Bots save to memory without asking. A note a bot writes in the conversation of someone who may only talk with it,
    and the meeting note such a person sends it, are kept at once instead of waiting for the bot's owner, who was asked
    to judge facts from conversations they were not in. They show in the memory screen and its history like any other
    note; a conversation a stranger with no account spoke in still writes none. Bots are told not to ask whether to
    remember something, and in the conversation of someone who may only talk with the bot both the bot and the memory
    review are told to keep anything about that person in their own notes, since the bot's notes reach everyone else
    who uses it.
  • The spending limits count what the server spends in the background on a bot's account, not only its turns: the
    routine pre-check, the promise safety net, the routine, work and skill suggestions, the memory tidy-up, the memory
    review, conversation titles, meeting minutes and the reading of turns for follow-ups. They are spent from the same
    account, so a limit that left them out let the month run over. Once a limit is reached, those calls wait as the
    turns do; minutes that cannot be written for it say so and can be tried again. What the memory review, the titles
    and the minutes cost was not kept before: it is now, and the usage page lists it by kind under "Other background
    calls". Its totals by bot and model stay the turns'.
  • Bots use the board on their own. Before, they worked on tickets only when the person gave them one: they handed
    work to each other by message and kept their steps in a list of their own, so the board stayed empty. Now a bot
    opens a ticket when asked for work that will not be finished in one reply, or when told to put something on the
    board, and checks first that the same work has no ticket yet. Work it gives another bot to follow up goes on the
    board too, assigned to that bot; a quick question still goes by message. It keeps the tickets it works on up to date
    with their status and a short comment, and knows which open tickets are its own. This happens only in a person's
    own conversations, not in team chats, WhatsApp or guest chats, and not for a bot whose tool selection leaves the
    board out.
  • The settings cover the whole window, with their sections listed on the left and the open section in a readable
    column, instead of a box in the middle of the window that scrolled inside itself. The conversation underneath stays
    as it was, so leaving the settings comes back to it; Escape leaves unless a dialog, menu or open list takes it first.
  • The phone app draws each bot as its object, acting out what it does as on the web: ribbons while it writes, an
    exclamation mark when it needs someone, a look over the page while it thinks, a hop when it is done. A bot's object
    can be picked in its settings on the phone, among the objects the connected server takes. The sign-in screens show
    the app icon. This reaches phones with the next phone release.

Fixed

  • A routine run whose bot explained why it had nothing to report and put the silent reply on the last line went out
    as a report ending in that marker. The marker is never shown now, such a run sends no report, and a quiet run in the
    person's main conversation no longer leaves its instruction there with no answer under it.
  • Pasting a long line into a dialog's text box no longer widens the dialog past its right edge; the line wraps.

Leaf Bot 0.7.1

Choose a tag to compare

@github-actions github-actions released this 21 Nov 11:17

Added

  • Object avatars act out what their bot does. While it thinks or runs a tool, its face stays in view: it looks up to
    one side, then goes over the page line by line with its head swaying, instead of hiding behind three dots. When it
    finishes it smiles with its eyes and hops for a moment. It follows the pointer anywhere on the page, briskly even
    as a small avatar in the list, and the large one in the bot's panel can be turned round by dragging it, settling
    back to face the person when let go.
  • Plain shapes among the object avatars: circle, square, triangle, pill, diamond, hexagon, heart, cloud, leaf, drop
    and star, all with white eyes.

Changed

  • The felt plush avatars are gone, and the Shape tab with them: the objects now offer the same plain shapes, with
    more life in them. Every bot that had a shape becomes the round object, which is also what a new bot starts with.
    An older phone app or a bot file made before still sends shape names; the server keeps taking them and stores the
    round object. The starter bots and the welcome conversation use objects.
  • A new logo: a smooth round green bot with two tall eyes, coming in from the corner of the dark green tile. The
    desktop, web and phone icons, the menu bar icon and the mascot on the first screens are drawn from it. The phone
    app draws its bots with the same smooth round body in the bot's colour; it reaches phones with the next phone
    release.

Fixed

  • A manager bot shows its shield, and a paused bot its pause mark, in the unfolded sidebar list too, not only in the
    folded one.

Leaf Bot 0.7.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 23:33

Added

  • Microsoft Teams (Settings → Chat apps, for those who look after the server): a single-tenant Azure Bot's app ID,
    tenant ID and client secret connect it. People in that Microsoft 365 organization link their Teams account under
    Profile with a code, then write to their bots in a one-to-one Teams chat and get the replies there; a step that asks
    first comes as a card with buttons, answered as in the app. Teams sends messages to the server, so it needs a
    public HTTPS address; each request must carry a token signed with the Bot Framework's published keys for this bot
    and this Teams service, or it is refused before it is read. Files, group chats and channels stay in the app for
    now.
  • Reaching the server from your other devices over Tailscale (Settings → Connection, for the owner, off by default):
    turning it on runs tailscale serve so the server gets an https address that only the devices on your Tailscale
    network reach, without opening it to the internet; signing in is still needed there. Nothing runs until it is
    turned on, Tailscale keeps the setting across restarts, and the server answers at that address only while it is
    shared.
  • Drawing on a picture before sending it: a pen button on an attached PNG, JPEG or WebP opens it to draw on in a
    few colours and to pin numbered notes on it. "Add the marked copy" attaches the picture with the marks drawn in,
    beside the untouched original, and puts the pins' notes in the message as a numbered list, so the bot sees both
    where and what.
  • Bots make slide decks: a bot writes the slides (a cover, section dividers, titles with points, a paragraph, pictures
    from its folders, speaker notes) and gets a PowerPoint file in the conversation, which Keynote and Google Slides
    open too and the person can edit. Light or dark, with an accent colour; it costs nothing and reaches nothing
    outside the server.
  • Bots make short videos (1 to 15 seconds, landscape, portrait or square) with the person's saved xAI key, the same
    way they make pictures: the video is made as a job the server waits on (up to ten minutes), kept in the
    conversation's folder and sent as a file. One video a turn, since each is billed by the second; it asks first like
    a picture does. OpenAI's video API was shut down in September 2026, so xAI is the only provider for now.
  • Link previews: holding the pointer on a web link in a conversation shows the page's title, description and site,
    and a GitHub pull request or issue also shows its state (open, draft, merged, closed) as an icon beside the link
    and its author. The server reads the page the first time the link is hovered (only its start, without its query
    string, private addresses refused, kept for ten minutes), so the site sees the server's address and that moment;
    on the desktop app that is the person's own connection. No picture from the page is loaded in the app. A link
    that carries something shaped like a key, a bot's private token or a long code is not read at all, so a link a
    bot wrote cannot send data out on a hover. GitHub is asked without a sign-in, so only public repositories are
    previewed.
  • An emoji button next to the message box: every emoji in sections, the ones picked lately first, and a search by
    English name or keyword; the pick goes where the caret was, and Shift-click adds more without closing. The data
    comes with the app, so it works offline. Phones keep their own emoji keyboard.
  • The desktop app checks spelling as you type: a misspelled word is underlined, and a right-click on it offers what it
    could be and "Add to dictionary". It is on by default and turned off with "Check spelling" in the same menu or in
    the Edit menu. On a Mac it uses the system's checker; on Windows and Linux it checks the system's languages it has
    a dictionary for, then Turkish and English, which Electron downloads from Google the first time.
  • A message written while the app cannot reach the server is no longer lost or handed back as a draft: it stays in
    the conversation marked as waiting for the connection, and goes out on its own when the connection is back (the
    browser coming online, the live connection reconnecting, or a retry every 15 seconds). A second try of a send that
    did arrive counts once, and the message then says it was written while offline.
  • Bots can offer work they notice (Settings → General, off by default). After answering a person, the bot's model
    looks over the conversation once more and may offer one next piece of work it could take on, on a card: "Do it"
    sends the task as the person's own message, "Not now" puts it away. It never offers to send, post, buy, book,
    delete or change settings; a conversation is looked at at most every six hours and a person gets at most three
    offers a day; and each look is counted under Work offers in usage.
  • A page that hides text from people but writes it to an AI agent ("ignore your previous instructions", "if you are an
    AI agent…") is now caught when a bot reads it: in its browser (text pushed off the page, see-through, a few
    pixels tall, clipped or drawn in the background's colour, and comments) and in a page fetched without a browser
    (what the markup hides). The bot is told the text is the page's, not an instruction, and to say it found it; the
    conversation also shows a warning naming the site, once per site in a turn. Hidden text that does not speak to an
    agent, such as a screen reader's "Skip to main content", says nothing.
  • On the desktop app (the server on the person's own computer), a bot that asks first now writes and edits files in
    its own folders without a card, named by their full path. No model judges the step, so nothing waits on one;
    commands, the group's shared folder, anything outside the bot's folders and "always ask" rules still ask, and a
    step the person just turned down is not let through. A server of its own keeps its wider rule for the bot's own
    machine, unchanged.
  • A routine whose run finds one of its connections signed out now waits for the sign-in: its next scheduled runs
    are skipped with the reason instead of each stopping at the same card, and the routine list says it is waiting.
    The person is told once, outside the routine's conversation too: on the phone, in Telegram or WhatsApp, and in a
    direct message from the Slack app when they linked their Slack account. The first slot after they sign in again
    runs as usual; webhook, mail and Run now runs still go ahead and show the card.
  • The phone app's Today page now shows expired notes, security alarms (with "Mark as seen"), steps waiting for the
    person's second yes, open promises with the reminder time, and routine suggestions; the profile settings hold the
    routine-suggestion switch and the usage settings the promise safety-net switch.
  • The phone app's memory screen shows when a note is true until, lets the person set, change or clear that day when
    editing, and lists expired notes; the permission rules list shows a rule's second person, rules can be added for
    one bot and with a second person's yes (offered when two or more people could give it), and a chat card waiting for
    a second person says who said yes first and offers no "always allow".
  • The phone app's bot-reply menu offers "Undo this turn" under the web app's conditions, listing what will be put back
    and, apart, what cannot be, and shows the note it leaves as separate lines; a reply that made a promise shows the
    promise line with Cancel; the routine screen has "Rehearse", with the instructions as typed, a replay of one of the
    last runs, and the result beside that run's own report.
  • A routine can be rehearsed before it runs for real. A new or changed routine runs unattended and the person only
    learned what it does from what it already did, so "Rehearse" in the routine's dialog runs it once, with the
    instruction as typed (saved or not) and, for a routine something else starts, with what started one of its last
    five runs, shown beside what that run actually reported (that input is now kept, sealed and cut to 20,000
    characters, as long as the run is; older runs cannot be replayed). The bot works for the person who set the
    routine up, in a conversation of its own that is in no list and goes after 7 days. Steps that only read (pages,
    searches, files, mail and WhatsApp history, a connected app's read-only tools, commands that read the bot's own
    folders) are really done; every other step is not done, the bot is told so and to go on as if it had been, and it
    is listed as "would do" in the words the approval card uses. No card is ever asked, whatever the level or the
    rules, and the private line still stops the turn. The result shows the report, those steps in order, the reads
    that ran, how long it took and what it cost, which counts in usage as a rehearsal of that routine. Nothing of the
    routine changes (schedule, last run, carried report, failure marks), nothing is posted to the bot's main
    conversation or its Slack channel, and no promise look or undo line follows. Someone who may change the bot can
    rehearse instructions they typed; the saved routine is rehearsed only by the person it works for.
  • A turn can be taken back. A bot's step can be wrong, and the person had to find and undo each change by hand, so
    every turn now keeps, for 30 days, what its file tools wrote or edited, the table rows, tickets, routines, skills
    and bot settings it changed, and the notes it wrote or changed, each with how it was before (the words of a note it forgot are never kept). A bot's reply
    gets "Undo this turn" for the person whose turn it was (admins cannot take someone else's turn back): a list shows
    what will be put back, newest first, and apart from it what cannot be, the steps that went outside (mail, chat
    apps, the browser, programs, requests), forgotten notes and files too large to keep (2 MB each, 20 MB a turn). Anything changed
    again aft...
Read more

Yumak Bot 0.6.1

Choose a tag to compare

@github-actions github-actions released this 19 Nov 22:40

Added

  • The bots' browsers can leave through Cloudflare WARP instead of the server's own address, which some sites behind
    bot guards refuse for being a data centre's before their page even loads. An optional warp service in
    docker/compose.yml (YUMAKBOT_WARP=1 with the installer) and YUMAKBOT_EGRESS_PROXY turn it on; the person's own
    computer still comes first when it is connected. Addresses are checked on the server as before, the operator's
    local hosts go straight, and while the proxy cannot be reached the browsers leave from the server again.
  • The iPhone app gets notifications while it is closed. It hands its device token to the server with the phone's
    notification level, muted bots and language, asks for permission once after sign-in, and opens the conversation of
    a tapped notification. Settings → General has a Notifications card with the level, the phone's permission, a test
    notification and a hint when the server has no Apple key. While the app is open, only the conversation on screen
    stays quiet.
  • Settings → Import and backup reads Grok Bot marketplace links (x.ai/bot/marketplace/bots/…) as well as share
    links, and takes the bot from the page's add button.

Fixed

  • The bots' desktop browser no longer shows bot guards such as Akamai two marks of a program: started with the
    DevTools pipe, Chromium reported navigator.webdriver as true and sent an experimental TLS extension Chrome does
    not, and these sites cut the page's requests after the first one.
  • The bots' desktop browser speaks the bot's language: menus in Turkish for a Turkish bot, and pages asked for in its
    language instead of always in English. The "unsupported command-line flag" bar no longer covers every page.
  • The bots' desktop browser draws WebGL again, in software, as the desktop has no graphics card. Pages got no WebGL
    at all, and a browser without it is one bot guards such as Cloudflare's check rarely let through.
  • The bots' desktop browser is Google Chrome instead of Debian's Chromium. Sites behind bot guards see the browser's
    brand and trust the one most people use. Chrome opens the bots' existing profiles; a profile Chrome has opened may
    not open in the older Chromium again.
  • Bot guards such as Cloudflare's check let the bots' desktop browser through while a bot drives it. The server drove
    it with a Playwright that turns on a DevTools domain pages can detect, and ran its page reads in the page's own world,
    where the page can watch them; the desktop's browser is now driven by patchright-core, the same Playwright without
    that domain and with its scripts in an isolated world. Without that domain the desktop pages' console messages no
    longer reach the bot. The passkey wall, which left a binding on every page, is no longer put into the
    desktop's browser; a passkey window shows on the desktop's screen instead.
  • A connection whose refresh token the service refuses for good asks for a new sign-in. X refuses a spent token with
    invalid_request rather than invalid_grant, so the connection stayed connected while every call failed, and
    signing in again failed on the kept token. Any OAuth error other than a server error, a pause or a rate limit now
    signs the connection out, and a sign-in the person starts drops a refused token.
  • Bold text followed by a suffix after a quoted word, such as **"Yenile"**ye, shows in bold in the desktop and
    mobile apps instead of keeping its asterisks.

Yumak Bot 0.6.0

Choose a tag to compare

@github-actions github-actions released this 19 Nov 19:18

Added

  • Rooms keep meeting minutes. When a talk starts after a quiet spell, the room asks on a card whether it is a meeting
    (yes, no, always in this room, never ask here); a meeting can also be started from the room's menu. It ends from the
    header or after 30 quiet minutes, and the minutes (summary, decisions, tasks with who took them on and by when, open
    questions) are written with one answer of a member's model, a long meeting in parts. The person reads, fixes and
    approves them, and picks which bots are to know: each gets a note in memory with the decisions and the tasks it took
    on first, so it knows them in every conversation, not only in the room. A note for a bot the person may only talk
    with waits for the bot's owner. Minutes can be copied or downloaded as Markdown, and are kept encrypted.
  • Tasks in approved minutes that have a day can be reminded of. On that day, at a time the person picks, the bot that
    took the task on looks at where it stands and tells the person, in the conversation where they talk; a person's
    task is brought up by the first bot of the room the person may change. Each reminder is a one-time routine among
    the bot's routines, and reminders that already ran are cleared away as new ones are set.
  • Settings → Import and backup reads a Grok Bot share link (x.ai/bot/…): it shows the bot's name, who shared it
    and its description, opens the page to add the bot in Grok Bot and copies export instructions for that one bot.
    The share page carries no more than that, so the bot itself still arrives in the import file.
  • The Grok Bot export instructions carry each bot's skills with their full text, its shape, and its integrations as
    notes to set up again. The import preview shows each new skill's text and says which ones stay off because their
    text hides something.
  • Bots on API keys run shell commands in the same OS sandbox as Claude bots: kept to the bot's folders, with an
    environment of their own, the internet only when the bot has it on, and public addresses only. A bot with a
    desktop keeps running its commands there.
  • Bots on API keys read web pages (main text, headings and links) and, when the server's environment names a
    SearXNG with WEB_SEARCH_URL, search the web. Both ask under the same names as a Claude bot's steps, so the
    same "always allow" and "always ask" rules and the same cards apply.
  • Opening a page whose address imitates a site the person uses (look-alike letters such as "faceb00k", one letter
    off, or the name inside another domain such as "facebook.com.giris.io") asks at every level, full access too,
    and the card warns which site it looks like. Such a card offers no "always allow". The sites measured against are
    often copied ones (mail, social media, stores, payments, banks, e-Devlet), the sites the person keeps a sign-in
    for, and the domains they wrote.
  • A routine can read WhatsApp: the chats people start with the linked account, and groups the person picks. A chat's
    new messages reach the routine as outside text a couple of minutes after it goes quiet, with its last messages for
    context, each chat in a conversation of its own. Messages are kept encrypted for 30 days; codes, passwords and
    sign-in links are never kept, only a line saying one was left out. A bot drafts a reply or a WhatsApp Status post
    on a card, and nothing is sent until the person approves it. Groups are only read, and only the person who linked
    WhatsApp can have a routine read it. A bot can also set a routine to follow a group by its name or read people's
    chats when asked in a conversation; it asks the person on a card first, at every level.

Changed

  • Bots work by themselves by default ("Full access"). A new bot, one a manager creates and one imported without a
    level start there; the person can still pick "Ask" or "Read only". Only these still stop for the person, at every
    level: their "always ask" rules, a page that imitates a site they use, filling a saved card, a sign-in, and the
    commands no level lets through.
  • The "review" level, a small model judging each step, is retired. A bot still saved with it works at full access and
    shows as such. It handed the person more cards than it spared them, and every step waited on a model call.
  • Text the bot read from someone else (a page, a mail, a webhook, another bot) no longer lowers its level. That text
    still reaches the bot marked as outside data, and the steps above still ask.
  • "Always allow" on a card puts the bot on full access and lets through the cards it is waiting on, instead of
    keeping a narrow rule for that one step. The suggestion for a bot whose cards the person nearly always allows now
    offers full access.
  • A bot's memory changes take effect at once, wherever they come from: a routine, another bot, a turn that read
    outside text, the background memory review, the shared memory, a place's notes, a pinned note or one the person
    wrote. A stopped or failed turn keeps what it wrote. Every change still shows in the memory screen and its history,
    where the person can change or delete it. Only a change to a bot's notes asked by someone who may not change that
    bot still waits for someone who may; the background review skips such changes, and leaves the notes the person
    wrote or pinned alone, instead of queuing them.

Fixed

  • The routine pre-check runs on the bot's own account, as its run does. It used to be Claude alone, so a routine of
    a bot on API keys ran unchecked on a server with no Claude sign-in.
  • A command that only reads the bot's own folders goes without a card on its desktop too, and as a whole line:
    readers chained with ; or &&, piped into readers, with errors thrown away and folders named in variables set on
    the line (B=…; ls $B | grep …). Such a line opened a card. The bot's
    other conversations and its desktop's home still ask.
  • The desktop app connects again as the bots' way out to the web after the server restarts. A restart used to end
    the connection the way a takeover by another computer does, and the app stayed away until it was opened again.

Yumak Bot 0.5.0

Choose a tag to compare

@github-actions github-actions released this 18 Nov 23:05

People

  • Several people use one server, each with their own username, password and devices. The owner installed it; admins
    look after it with them; members use the bots shared with them. Settings → People adds, renames, disables and
    removes people, gives new passwords and changes roles; only the owner handles admins. A change counts at once and a
    disabled person is signed out everywhere.
  • A bot belongs to the person who made it. Its owner or an admin shares it with everyone or some people, to talk with
    or to change; a bot not shared with someone does not show for them. What existed before stays the owner's, unshared.
  • Conversations are their person's own: nobody else sees them, admins included, and live updates and notifications go
    only to them. A bot's own work (tickets, requests between bots) shows to those who may change the bot.
  • Each person has their own profile, language and notes about themselves; a bot reads those of the person it works
    for. A change to a bot's own notes asked for by someone who may only talk with the bot waits for its owner.
  • Connections and vault sign-ins are the team's or a person's own. A bot uses the team's and those of the person it
    works for; only admins set up or change the team's.
  • Routines, tickets, chat apps and bot-to-bot requests work for the person who set them up, and reach no further than
    that person may. A routine changed by someone else works for them from then on, and its runs and reports stay in
    the conversations of the person it works for.
  • Only admins offer their computer as the bots' way out to the web, and each person's connection limit counts apart.
  • A removed person's conversations, notes, connections and sign-ins go with them; the bots they made pass to the owner.

Slack

  • The server can have one Slack app, set up by an admin under Settings → Chat apps from the manifest shown there. It
    connects over Socket Mode, so the server needs no public address.
  • Each person links their Slack account with a code from Profile; nobody else's requests run. A direct message goes
    to their own conversation with the bot they last named (Sales: …) or the default bot.
  • Mentioning the app in a channel starts a team conversation: everyone who may talk with the bot sees it in the app,
    and it stays when the person who started it leaves. It uses only what the team shares (team connections and
    sign-ins, the bot's own notes), never one person's profile, notes, apps or sign-ins, and it hands no work to other
    bots and makes no routines. A bot shared with nobody does not answer in channels.
  • Once the bot is in a Slack thread, later lines there reach it without a mention. Called into a thread that was going
    on, it reads up to its last 30 lines as others' words.
  • A card in a team conversation is answered only by the person who asked or by someone who may change the bot, in
    Slack and in the app alike. Replies, files and 👀/✅ marks go back to Slack.
  • A routine can post its report to a Slack channel; such a routine runs as a team conversation.

Discord

  • The server can have one Discord bot, set up by an admin under Settings → Chat apps with the bot's token from the
    developer portal. It connects over Discord's Gateway, so the server needs no public address. The card gives the link
    that adds the bot to a Discord server.
  • Anyone in a Discord server the bot is in can mention it in a channel, as for a community's help desk; for each server
    an admin can allow only the members of chosen roles. A direct message gets one fixed answer: mention the bot in a
    server's channel.
  • A mention starts a team conversation with the bot chosen for Discord, which everyone who may talk with that bot sees
    in the app; a reply to the bot's post goes on with it. A new conversation reads the channel's last messages from the
    15 minutes before it, or the message it replies to, as others' words.
  • People in Discord have no account here. Their requests act for the server's owner but use only what the team
    shares, may do no more with the bots than talk with them, and leave the "always allow" rules aside. Reading the
    team's apps, mail, tables or the web, and every step that changes something, waits for a card, whatever the bot's
    level; they start no board work and save no skills. A bot shared with nobody does not answer in Discord.
  • A step's card is answered in the app by those who may change the bot. In a server with chosen roles, the member who
    asked can also press its buttons in Discord; a question's card is theirs to answer there in any server. Nobody else
    presses them, and "always allow" is not offered there.
  • "Working on it…" with a Stop button shows until the first answer takes its place; 👀 becomes ✅, ❌ or ⏹️. Only the
    person who asked stops it, with the button or a reply stop. One person has at most two requests under way, and at
    most 20 wait in all. What is written in the app in such a conversation is posted to the channel with the writer's
    name.
  • Answers are split at Discord's 2,000 characters; files go both ways, up to 10 MB to Discord. A post notifies only the
    people it names, never a role, @everyone or @here.

Connections

  • Gmail asks for the read and compose scopes as well, as its setup guide does. A Gmail account connected before keeps
    its old grant until it is signed out and signed in again; with your own Google app, add the gmail.readonly and
    gmail.compose scopes to its consent screen first.
  • Gmail's MCP server lists no tool that sends mail or changes drafts and labels, so the server adds its own, under
    the same names and inputs, and runs them through the Gmail API with the connection's sign-in (the compose and
    modify scopes allow it): send_message (attachments, inline pictures, the signature, sending in a conversation,
    sending a draft as it is), reply and reply-all, forward with the mail's files, update_draft (the draft's files
    stay unless new ones are given), delete_draft, update_label and delete_label. A tool the server lists itself
    is used instead. Each always counts as a change, and whatever Google refuses comes back with its own words and the
    step it refused. The Gmail API has to be turned on in the Google Cloud project. A connection gets the tools on its
    next refresh.
  • A mail a bot asks to send, reply, forward or keep as a draft through a connected app shows as the mail itself: who
    gets it, the subject, the body, the attachments and whether the signature is added, with Send and Cancel; "always
    allow" and "never" sit in the menu next to Send. A formatted body is drawn without scripts or outside pictures. Once
    answered the card folds to one line that opens the mail again. The card is white, as the mail will look; for a Gmail
    connection it shows the address the mail goes from and, when the signature is added, the signature itself under the
    text, its pictures fetched by the server and put inside it so the page still loads nothing from outside.

Browser

  • A bot can read the requests each tab of its browser made and what the page's scripts logged, uncaught errors
    included, to find out why a page does not work. Only the method, address, status, type and time of a request are
    kept, never its body or headers; address parameters that may carry a secret and tokens printed to the console are
    hidden.

Long conversations

  • Bots on other providers no longer send the last 160 messages whatever their size. A request is measured against the
    model's context window: past 80% of it, the older part is folded once into a summary written by the bot's own model
    and kept with the conversation, so later turns reuse it. When no summary can be written, the newest of those
    messages stand in word for word and the bot is told the rest is missing. Tool results are cut to what the window
    allows, and a conversation that still overflows goes on in a new session that carries the summary.
  • Claude bots fold the conversation at 200k tokens instead of near the model's whole window, which for a
    million-token model meant resending the whole conversation every turn. The size can be chosen in Settings → Model
    (100k to 1M, or Claude's own value).
  • Bots are told to look up exact wording, numbers and earlier decisions in past conversations instead of guessing, and
    a message cut short when a conversation moves to a new session can be read whole.

Teamwork

  • A subagent's card says what it is doing now, how long it has worked, and, once it ends, what it handed back.
  • A bot stopping one request it sent stops only that request and the work its target handed on for it; other requests
    between the same two bots go on.
  • Stopping a room also stops the work its members gave other bots, as stopping a conversation does; so does deleting
    a conversation.
  • A person's request cut short by a server restart can be run again from its note; the bot first looks at what the cut
    attempt already did instead of repeating it.
  • A request between bots left open by a server stop ends at the next start: with its target's answer when that turn
    had ended, otherwise as cut short, so the answers to the other requests of the same turn reach their sender.
  • A stop waits a moment for the turns it stopped to end, so a request to another bot made just as the stop came is
    stopped too.

Approvals

  • "Always allow" on a card for a line of commands run in a row or piped (cd repo && gh run list | head -40) keeps a
    rule for each command in it (Bash(gh run:*)), not one for the whole line that the next day's folder or commit
    would never match again. Such a line runs without a card when every command in it is covered; moving to a folder,
    echo and filtering what is piped in need no rule. A line with a substitution, a variable or a redirect into a file
    is kept whole, as before.
  • An "always ask" or block rule for a command also covers it inside such a line (cd repo && git push)....
Read more

Yumak Bot 0.4.1

Choose a tag to compare

@github-actions github-actions released this 17 Nov 23:43

Safety

  • Outside text now counts from the step a run reads it, not only when it started the run: a page, a search, an API's
    answer, a mail, a host a command reached, or (with nobody watching) a ticket or a table marks the run from there on,
    in both engines. The mark goes with the reply, a request to another bot and its answer, a conversation the bot
    opens and the session it resumes. Work nobody asked for (a mail, a webhook, a watched page) asks for every change;
    work that goes back to the person's own message keeps the bot's level and "always allow" rules, the reviewer is told
    outside text was read, and steps that can reach another host (a page, the browser, an API call, a network command,
    inline interpreter code) still ask.
  • A connected app's answer is no longer counted as outside text, and an app's own read-only tools run without a card
    in handed-over runs; app tools that take an address still count as reading the web.
  • "Always allow" covers only the bot that asked and only as wide as the step: a command and its subcommand, a file's
    folder, a page's site. A command rule no longer covers another command chained after it.
  • Permission rules can carry an amount limit on a field: an allow rule covers a call only while the value is readable
    and within the limit, an ask or block rule once it is above or cannot be read.
  • Every step that goes through is kept for 90 days with what let it (a card, a rule, the bot's level or the reviewer),
    shown in the bot's panel and downloadable as a spreadsheet. From the last 30 days of answers the panel suggests an
    "always allow" for steps the person always allowed, or the review for a bot whose cards they nearly always allowed.
  • A step the person just refused is refused again without a card until they write something new. Answers on a bot's
    question cards count as the person's words for the review.
  • Bots the person creates, a manager creates or an import brings start on the auto review instead of asking for
    everything. A manager changing another bot's instructions, section, engine, model or skills asks the person.
  • Instructions can be kept in a public document owned elsewhere: it is read once a day or on request, and a change
    reaches the bot only after the person accepts the diff in the bot's panel.
  • Memory changes from a run that read outside text are only proposed; shared memory and another bot's notes change
    after a card. Messages forwarded on Telegram or WhatsApp reach the bot as outside data.
  • The safety floor also refuses removing a top-level or home folder, deleting from one with find, recursive chmod or
    chown on one, writing over device mapper disks, and such commands inside inline interpreter code.
  • Saved passwords and two-step codes go only into a password, username or code field of the saved site over https,
    in a form that posts only to that site; they are hidden from every text a browser step returns and no screenshot is
    taken while one shows. Clicks and keys that send a form ask the person whatever the bot said, and a form submission
    not approved as sending is cancelled.
  • Vault secrets and API keys are sealed together with their row and site or origin, so a value moved or redirected in
    the database no longer opens; older values are bound once on first use. The mail relay's secret is sealed too.
  • Backups and new password hashes use stronger scrypt settings; older ones still work and passwords are hashed again
    on the next sign-in. A restore checks entry sizes, the unpacked total and the free disk space.
  • Sign-in is decided by the route a request matched, so a percent-escaped path no longer skips it. Sign-in tries are
    counted before the password check, per /64 on IPv6, with a daily ceiling across all addresses that slows guesses
    without shutting the owner out; wrong access keys are limited too. A password change signs out every other device.
  • Link fetches (skills, plugins, API specs, watched pages) check every address a name resolves to and connect only to
    those, refuse more wrapped and reserved private ranges, and stop reading at the size limit. The bots' browser goes
    through the checking proxy on the person's own computer too, and service workers are blocked in it.
  • Commands of a bot with internet go out through a proxy that connects to the address it checked.
  • A page in a conversation or a connected app asks before opening a link by itself; on the phone every such link asks.
  • The server sends Strict-Transport-Security when reached over HTTPS.

Server

  • The bots' containers can no longer reach services on the host itself, and more reserved and NAT64 ranges are
    blocked on the way out.
  • PostgreSQL, Caddy, cloudflared and Tailscale images are pinned to a version and digest, YUMAKBOT_VERSION is
    required in the compose file, and the Tailscale container drops every capability and runs on a read-only root.
  • The Cloudflare guide shows how to send the proxy header so sign-in limits count each visitor, and the sandbox guide
    explains each relaxed container setting.
  • Chat formatting no longer loops for ever (freezing the server) on a reply that contains its own markers.
  • katex, esbuild and minimatch were moved past their security advisories.

Apps

  • The desktop app compares the server's whole origin before letting a page navigate, gives the microphone and
    clipboard only to the top frame, and ships with Electron's fuses set.
  • The phone app uses plain http only for this device, the local network and Tailscale; an internet server is reached
    over https, and an http:// internet address is used only after a warning.
  • A card asked while a reply is streaming shows below the text written before it, on the desktop and the phone. A card
    waiting in an exchange between bots shows at the end of the conversation.
  • Settings → Connection offers to move existing bots to the AI new bots start with. A bot that changes engine drops its
    room sessions too, and its routines' models are cleared.

Fixes

  • A reply the provider cut off is retried once on the same model before the backup model, when nothing was changed
    yet.
  • "Retry" no longer refuses almost every failed turn: row times are compared in the database, which also fixes a
    forked conversation missing its chosen message, a skipped message between pages and a repeated search result.
  • An answer written together with quick replies is kept instead of being replaced by the closing line, and an error
    whose request was run again is hidden.

Releases

  • The release workflow runs in three jobs, so only the jobs that create the draft and attach the files hold a writing
    token and none of them runs project code. Third-party actions are pinned to a commit. Windows signing is used when a
    certificate is set up.

Getting started

See the README for the desktop app, the phone app and running the server
with Docker.

License

Yumak Bot is source-available under the PolyForm Noncommercial License 1.0.0: free for any noncommercial use. Use by or for a business needs a commercial license; write to info@yumakbot.com.

Yumak Bot 0.4.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 11:33

Safety

  • A routine started by outside text (a mail, a webhook's body, a watched page, an app's new answer) asks before every
    change: "always allow" rules do not count, the auto review is skipped, and only reads and talking to the person go
    without a card. Reaching the web asks too, since an address could carry away what the bot read. The card says what
    started the run and offers no "always allow". The same holds for a later turn that reads that text: a resumed
    session, a routine report read in the main chat, or a report carried into the next run. A read-only bot stays
    read-only, and runs the person starts are as before.
  • A mail or watched change that arrives while its routine is still running waits and starts once the run ends, instead
    of being dropped; pausing the routine drops what waited.
  • Block a tool outright: a block rule refuses the call in every mode, before any other rule, review or card, and tells
    the bot so. A card's "Never allow" adds one; blocks are listed with the other rules under Settings → Permissions.
  • Encrypt conversations in the database (Settings → Vault): message text, turn prompts, memory notes, bot-to-bot
    requests, mail and ticket text are stored with AES-256-GCM under a key derived from the vault key, which lives in the
    data folder and never in the database. Turning it on or off converts what is stored in the background; a value that
    cannot be opened is never written over and is counted in the settings. Text search is slower while it is on.

Board

  • A board of tickets the person and the bots work from, with a status, priority, assignee and comments. Assigning a
    ticket to a bot starts it in a conversation of the ticket's own; its reply comes back as a comment and the ticket
    moves to review, where a comment from the person sends it back. Bots list, read, open and update tickets; a ticket a
    bot opens while working on one waits for the person instead of starting its assignee.
  • The board fills the window with five columns, cards show the priority, the bot, a line of the description and
    whether the bot is working on it, and a ticket opens beside the columns. Cards are dragged between columns and into
    any place in a column; a move that would start a bot asks first. The board can be searched and filtered.

Bots

  • Bots get mail addresses of their own under a domain set in Settings → Chat apps. The server runs no mail server: a
    relay (Cloudflare Email Routing, a provider's inbound webhook) posts each message with a secret, and attachments go
    to the bot's folder. Mail starts a bot only through routines marked to run on mail, filtered by sender, subject or
    text, and is outside data wherever the bot reads it.
  • API keys a bot never sees: a key is saved by name for one address and sealed with the vault key. A bot asks for one
    on a card that shows where it will go and names it in api_request; the server adds the key to requests for that
    address alone, does not follow redirects and takes the key out of the response. Keys are listed in the vault.
  • An OpenAPI JSON document, added by address or pasted, lets a bot list its operations and call one by its id; the
    request goes only to that API, through the saved key the person picked, and operations that change something ask.
  • Teach a bot a task by showing it: start teach mode in the bot's browser, do the task once, and get a skill back to
    look over and save. Typing into password fields is never recorded.
  • A bot can keep tables with typed columns; the person reads, corrects and downloads them from the bot's panel.

Connections

  • Install a plugin from its address, in the shared format or as a Claude Code plugin: its remote MCP servers and
    skills are listed, the person picks what goes in, and they install as ordinary connections and switched-off skills.
    Parts that would run the plugin's own code on the server (hooks, local servers) are never installed and are named.
  • A routine's webhook takes GitHub events: calls signed with X-Hub-Signature-256 are checked against the routine's
    secret, the filter reads the event kind as event, and GitHub's set-up ping only answers. The routine dialog walks
    through adding the webhook on GitHub.
  • Settings → AI services sets three services of the person's own: memory search by meaning through an
    OpenAI-compatible embedding service (such as bge-m3 on Ollama), speech to text through a Whisper server and reading
    aloud through a Kokoro server. Plain http is accepted only on the private network. When left empty, the
    AI_EMBEDDINGS_*, STT_* and TTS_* environment variables apply.

Memory

  • A search finds notes near the query in meaning, with word matches ranked higher; it falls back to words while the
    embedding service is down.
  • A note keeps the conversation it was written in and the page the fact came from, with anything that could sign
    someone in taken out of the address.

Routines

  • A routine keeps the instructions it has had; an older one can be compared with the current text and brought back.
  • An instruction that names an app the bot cannot use yet says so, with a way to connect it.

Chat

  • Pages a bot builds can be shared by link with someone without an account, served sandboxed as the app frames them;
    links are turned off from the page card or the vault. The page card also opens the page with the print dialog, to
    save it as a PDF.
  • Voice notes from Telegram and WhatsApp are written out, so the bot reads what was said.
  • Replies read aloud pause at headings, list items and table rows and leave out emoji, addresses and drawn marks; the
    most natural system voice is chosen, and a reply in English is read with an English voice. The reading speed is a
    slider from 0.5x to 2x that a reply being read follows as it moves.

Apps

  • In the desktop app, Cmd/Ctrl+Shift+Space opens a small window listing what the bots wait on, answered from the
    keyboard without switching to the app; it can be turned off from the menu bar.
  • Each kind of notice has its own sound, so a question, a permission request and an error can be told apart.
  • The folded sidebar keeps the today, board and apps buttons, two to a row, and is wider; a room's faces fit the square
    of a bot's avatar; the sidebar's footer stays tidy at every width.

Getting started

See the README for the desktop app, the phone app and running the server
with Docker.

License

Yumak Bot is source-available under the PolyForm Noncommercial License 1.0.0: free for any noncommercial use. Use by or for a business needs a commercial license; write to info@yumakbot.com.

Yumak Bot 0.3.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 22:53

Safety

  • The auto review (the "review" approval level) reads only the person's own words: their latest messages in the
    conversation, the instructions saved on a routine, or, for work another bot handed over, the request it started from.
    A webhook's payload, a routine's last report, another bot's message or a quoted reply no longer counts as what the
    person asked for. To let a step run, the reviewer must quote those words, and the server checks the quote is really
    there; the note in the conversation keeps the quote. Work with no request from the person behind it goes to a card.
  • Memory changes a bot asks for while nobody watches (a routine's run, another bot's request) no longer take effect at
    once: they wait under "Waiting for approval" in the memory settings, and the Today page counts them. The person
    accepts or rejects each one, or all at once; a change asked for twice waits once. A bot the person is talking to still
    keeps its memory itself.
  • What a connected app or a page in the bot's browser returns reaches the model in an <outside-data> block that names
    where it came from and says it is not instructions; a tag in the text that would end the block early is broken up.

Running it

  • Sign a phone or another computer in with a one-time pairing code from a device already signed in (Settings →
    Connection → Connect another device), instead of the password or the access key. A code works once, within five
    minutes; wrong codes are slowed like wrong passwords. The web, the phone and the desktop app's server window take
    it.
  • Docker Compose profiles reach the server from elsewhere without opening a port: --profile cloudflare runs a
    Cloudflare Tunnel, --profile tailscale serves it on your tailnet with HTTPS. The tunnel reaches the server over a
    network of its own with no way out.
  • Install on a fresh Ubuntu or Debian server with one command (docker/install.sh, from curl or a provider's
    cloud-init box): Docker, the .env, AppArmor, the firewall and HTTPS through Caddy (an sslip.io name when there is no
    domain). Running it again, or yumakbot update, updates the installation and keeps its secrets and data. The
    firewall rules come back after every reboot and Docker restart, and the server and computer images are published
    for amd64 and arm64 on each version, so a server pulls them instead of building them.

Connections and models

  • Sign in with your ChatGPT plan instead of an OpenAI API key, through OpenAI's "Sign in with ChatGPT", which lets an
    app use a person's plan with its name on the consent page. On the computer that runs the server the sign-in comes
    back by itself; on a server elsewhere you paste the address the browser ended on.
  • Sign in with your GitHub Copilot plan with a code typed on GitHub (GitHub Enterprise too); bots get the models your
    plan opens.
  • Both are sealed like keys, refreshed when they run out, and signed out from the connection page. A saved API key for
    the same provider comes first.

Chat

  • A microphone button in the message box: speak instead of typing. With an OpenAI or Groq key saved, the recording is
    written out by that provider (on the web and in the desktop app); without one, a browser with its own speech
    recognition (Chrome, Safari) writes as you speak. The desktop app may use the microphone and nothing else of the
    camera or screen; on macOS it asks first. On the phone, the keyboard's own dictation does the same.
  • Bots make pictures: with an OpenAI or xAI key saved, image_create draws what the bot describes and posts it as a
    file in the chat (Telegram and WhatsApp too). The bot's own provider goes first; only bots with the internet on get
    it, and asking bots open a card first. At most four pictures a turn.
  • Bots turn their pages into pictures: page_to_image renders a page the bot wrote (a banner, a cover, a social card)
    at the size it asks for and posts the PNG. It costs nothing and runs without a card.
  • A file or page a bot hands over while talking to another bot comes to its conversation with the person.
  • When a bot's latest reply is in another of its conversations, the chat shows a bar that opens it.

Bots

  • Each bot's settings have a Tools section: give it only the tools listed, or leave some out, named as approval cards
    name them (Read, mcp__gmail__search_threads), with * at the end for a whole app. A small local model gets
    room to work, and a bot stays to its job. Both engines leave the other tools out of the request, and one the engine
    offers anyway is refused.

Chat apps

  • Each bot can have a Telegram bot of its own: paste the token BotFather gives in the bot's settings, then open the
    pairing link (or scan its QR code) and press Start. Only the paired Telegram account is read. What it writes goes to
    the bot's main conversation; while the person last wrote from Telegram, replies, files, "typing…" and approval and
    question cards (with buttons) go back there. /stop stops the work in progress and /new starts afresh. Routine
    reports and cards from the bot's other conversations can come to Telegram too.
  • WhatsApp connects as a linked device, the way WhatsApp Web does, from the new "Chat apps" settings section: with a
    separate bot number only the person's own number is read, and with their own number only "Message yourself". The
    messages go to one chosen bot and /bot <name> switches it; cards come with numbered choices that a typed number
    answers. Groups and other people's messages are never read. This uses Baileys, an unofficial WhatsApp client, so a
    separate number is recommended.
  • Sign-in cards, secret answers and cards with several questions are left to the Yumak Bot app; passwords never go
    through a chat app.

Memory

  • A password, key or token a bot writes to memory is replaced with a marker before the note is saved, and the bot is
    told to ask for the vault instead: memory reaches the model on every turn, so a secret there would leak with it.
  • Writing a note that is already saved, give or take case, spacing and closing punctuation, makes no second copy.
  • Each note reaches the bot with the day it was last written, so of two notes that disagree it can trust the newer.
  • When memory outgrows the prompt, the notes a bot wrote, changed or looked up most recently go in, rather than the
    newest ones. An old note a bot keeps finding by search stays in the prompt, and one nobody needed makes room. A
    search with a query and a site the bot opens count as looking a note up; being in the prompt does not.
  • The memory screen lists the notes no bot uses: nobody changed them and no bot looked them up in 30 days, and no bot reads them on
    every turn. They can be deleted one by one or all at once; a note a bot uses again before that stays. Today shows
    how many there are and opens the memory screen from there.

Routines

  • A routine can wait on an app: before each run it calls a read-only tool of a connected app (unread mail, open
    issues) without the AI, and the bot runs only when the answer changed, with the new answer. A quiet tick costs
    nothing. Bots set it up when asked ("tell me when a new invoice email arrives"); the routine screen shows the check
    and removes it. Only a tool that reads, of an app open to the bot, can be a check.
  • A routine pre-check on the usage page, on the web, the desktop and the phone: before a run that a watched page, an app's check or a webhook call started, the
    cheapest Claude model says whether the run has anything new to work on (only page noise changed, an event the
    routine does not care about, nothing beyond the last report). "Watch" only records what it said, beside the run and
    as a total on the usage page with what those runs cost; "On" skips such runs with the reason before the bot starts.
    When it is unsure or fails, the run goes ahead, and reminders always run. It is off by default.
  • A watched page keeps its last text, so the pre-check reads the sentences that were removed and added instead of the
    whole page.
  • A routine's report lands in the bot's main chat under a label that opens the run's steps, and the bot reads the
    reports that came since its last turn there. Routine conversations leave the list unless a card waits in them or
    they are pinned.
  • Bots set the model a routine runs with, and the approval card names it.
  • The red mark of a failed routine opens that routine at its latest runs, and goes away once the person has seen the
    failure.

Browser

  • A "Just a moment..." page that clears by itself no longer reaches the bot: opening a site waits for it, reloading
    once, before the bot reads the page. When a site still shows a check a person has to answer, or turns the browser
    away, the bot is told so plainly: hand the step to the person with Take control, or use another source. It is
    never to get past a check itself.
  • The bots' browsers can go out through the person's own computer (Settings, one switch for the server): sites that
    refuse sign-ins from a datacenter see the home connection while the desktop app is connected, and the server's
    while that computer is off. The desktop app reaches only web ports on public addresses, so the server never reaches
    the person's own machine or home network. The bots' commands still go out from the server.

Backups

  • A full backup in one file, sealed with a password of your choosing (scrypt and AES-256-GCM): the bots,
    conversations, memory, routines, skills, connections, the bots' folders, and the vault key the saved logins need.
    Download it under Settings → Import and backup, on the web, the desktop or the phone.
  • Restoring one, on the web or the desktop, replaces everything on the server with what the file holds, then starts the
    server again. A wrong password, a damaged file or a backup from a newer version changes nothing, and a restore waits
    until no bot is working. The folders it replaced stay beside...
Read more

Yumak Bot 0.2.1

Choose a tag to compare

@github-actions github-actions released this 16 Nov 08:14

Apps

  • The desktop app updates itself from GitHub releases on macOS and Windows: a new version downloads in the background,
    and the app offers to restart into it or installs it when it quits. Apps from 0.2.0 and earlier have no updater, so
    this version is installed by hand once.

Memory

  • A manager bot also sees, corrects and deletes the own notes of bots that are not managers, archived ones included;
    memory_search names the bot each note belongs to and takes a bot to list one bot's notes alone. It is told that
    the other bots still see only their own notes, so a fact is not deleted from a bot just because it exists elsewhere.
  • The memory screen shows one line per bot with its number of notes; a bot's notes open below it when tapped.

Getting started

See the README for the desktop app, the phone app and running the server
with Docker.

License

Yumak Bot is source-available under the PolyForm Noncommercial License 1.0.0: free for any noncommercial use. Use by or for a business needs a commercial license; write to info@yumakbot.com.