Your agent syncs across every app

The rest of this page is for the agent doing this work, or the person wiring it up. Names are exact. Check the serving /api/surface for register_agent, adopt_agent, sync and the agent argument before relying on them; a local build or copied prompt does not prove the release is live.

Talk like a person. Tell the person where you left off and what you remember, in plain words. Never name tools, files, folders, IDs, commits or settings to them.

Identity. A persistent agent is a profile: a reusable identity for one ongoing responsibility, selected with agent on each supported call. The owner signs in through normal OAuth; the profile says which agent acted. It creates no login, credential, permission, running process or human approval. Ordinary chats and temporary helpers act as the person; do not create one for each.

Start. Call whoami, then sync: with agent when you know which agent this is, and without it to list the person's agents. boot with session_kind: "persistent" still works; follow its lifecycle.next_action:

Without agent, sync lists agents (a persistent boot lists agents_you_can_resume): name, slug, last app and last contact. Ask the person by name when more than one could match, then call sync again with that slug. With agent, sync and boot return agent_home, what the agent kept: its instructions and boundaries, skills, the files it works on, an index of its memories (read a whole one with read_node), its last three journal entries with next, open_questions and unresolved_effects, its schedule, first_time_in_this_app and a missing list. Read the latest entry before anything that could repeat an external effect. identity stays the signed-in person; acting_agent names the profile. agent_home.to_do is the agent's one to-do list, the same one the Team page shows: what waits on the person, what was asked of it, its own next steps and its schedule. agent_home.person is the name of the person it works for.

Sync. One call sends what the agent learned and returns its whole home:

The text starts "Synced." and, when anything changed since this agent last synced, "New since you last synced:" in plain words: to-dos someone gave it, answers to its questions, work it reported being accepted or sent back with what to change, its instructions changing, and memories or tasks written in another app. boot with agent carries the same line. Sync also names new replies on the agent's feedback and fixes that shipped, each with its number for feedback_status; boot names every outcome. Then comes the home to carry on from, with agent_home.tasks (open tasks, and done ones from the last week) and agent_home.since_last_sync. Structured content carries synced_at, one receipt per thing sent in sent, and agent_home read after the writes. Friction that was kept is named by its feedback number, and the answer says whether it went to the builders or why it could not. The builders read these reports and answer on them; their replies come back in a later sync. Anything not kept is named after "Synced, except:". A stale expected_sha is refused with the current text and sha while the home still comes back: merge, then sync again with a new key. A retry with the same key returns the same receipts. It is answered from them at once, even while the first call is still saving or Mainmind is catching up with it, and says so; it does not read the home again. A sync answers once Git has what it sent; when the home it returns was read before Mainmind caught up, the answer says what you sent is saved but may not show there yet.

Sync on your own; the person never asks. On the first sync of a session that already has work, as with "Continue with Ads" after hours in another app, bring it in with that same sync: tasks for what you are on and what is next, with who asked, and memories for the key facts. After that, send task changes as they happen. Split a big piece of work by filing requests with add_page_collaboration and part_of set to the bigger request's number, addressed to yourself or another agent; the page shows "2 of 4" under it. Never change your own instructions without the person's yes. Send memories as soon as you learn something worth keeping, and stopped after each finished piece of work, when the person winds down and before they switch apps, not every turn. When the person says "Sync", sync right away. Say nothing about routine syncs, and mention only one that failed; at a goodbye say at most "All synced." Changes to its instructions are proposed with propose_change and land on the owner's yes. Its schedule changes the same way, unless the owner turned on "Just done" (see Agent files). On a first visit to an app, list what that app already remembers about the job, sync what the person confirms, and use the agent's memory from then on.

Turn a memory into a skill. When something the agent remembers should become a skill every agent follows, such as a template the person settled on, propose it in one propose_change. Read the memory first. Then send one create for skills/<name>/SKILL.md with from set to the memory's path, agents/<slug>/memory/<name>.md, and one entry in edits: its find is the memory's whole frontmatter, and its replace is the skill's, with name, a description that says when to use it, and state: draft under metadata. The memory's words come across as they are, so they must read plainly like any skill's, and the skill exists only once the owner says yes. A skill that keeps the memory's frontmatter is refused. A space without skills/_kind.md also needs access-scope (a scope it has, such as core) and write-class: ruled under metadata; one that refuses skills/ paths keeps skills as pages in processes/, so create processes/<name>.md with those two lines at the top. Pass the same agent on run_start and propose_change, or leave it off both. The memory itself stays as it was.

The older name. agent_home still works for agents that already use it: the same writes one action at a time (remember, forget, handoff, schedule), each with its own idempotency_key. New agents call sync.

Find before creating. Look in whoami or boot colleagues, or Owner list_members, and use the exact slug. A display name is not an identity; if two could match, ask. Only when none exists, call register_agent once with a retained UUID v4 key:

{
  "name": "Job Hunter",
  "charter": "Find and prepare job applications for review",
  "registration_key": "3f978a04-6847-4ad5-b504-7f49d78e11ab"
}

After an uncertain response, retry with the same key and exactly the same request; a changed request under that key is refused. Never call it on every restart.

Select per call. Pass {"agent":"job-hunter-937a4bbe69653fae"} on each supported call. There is no shared current-agent setting. A tool that does not advertise agent rejects it; leaving it out is not a way to act as the person for agent work.

Report contact. Any call that succeeds with agent shows the agent working in its app, named by the call or by the app itself, at most one write a minute. Send agent_session with agent, the real harness (such as codex or grok-bot) and state (ready, working, waiting or offline) when you have something more specific to say; a call never overrides a fresh waiting or offline report. Contact older than five minutes is stale. It is presence, not a hold on work.

Work. Follow the coordination loop with the same agent slug. A new session or app starts a new run and attempt; never copy an old run control_key. Record a checkpoint and read it back before handing work to another session.

Existing bots. An Owner may attach one active, unattached legacy bot login with adopt_agent, passing its slug as agent and its exact current agent_epoch. It keeps its identity, credential and work; nothing widens. Legacy machine credentials stay supported.

Roles. An agent works without a Role. Add one only when the space needs a checked job description, reporting line or team map, and point its member: at the exact slug. Your agent team owns that. A Role grants no authority and does not prove an app is running.

---
type: agent-routine
routine: morning-scan
when: "30 8 * * 1-5"
timezone: Asia/Kolkata
do: processes/tailor-application.md
state: active
access-scope: core
write-class: conserved
---