Give Codex ongoing responsibility. Keep judgment in your hands.
Tend turns intent into local, reviewable feeds that you can inspect, steer, and teach over time.
Caution
Tend is experimental software. It is being released to explore a new way of working with Codex in public. It comes with no support and no guarantees of stability, compatibility, correctness, data retention, or continued development. Expect breaking changes, keep backups, and do not rely on Tend for critical or irreversible workflows. The software is provided "as is" under the MIT License.
Most agent work begins and ends with a prompt. Tend starts with an ongoing intent: keep me on top of important mail, show me whether a project is getting healthier, or surface conversations that need my attention.
You describe what deserves attention and what good judgment looks like. One dedicated Codex thread tends that feed over time: it checks relevant sources and brings back meaningful changes. Tend is where you review those changes, decide what happens next, and teach the feed how to improve.
The unit of work is not a prompt. It is a responsibility.
- Define the intent: describe what you want to stay on top of in plain language.
- Delegate attention: give one dedicated Codex thread durable responsibility for the feed.
- Review meaningful change: receive source-backed cards when something deserves judgment or action.
- Steer the judgment: correct, refine, approve, or redirect the work instead of supervising every step.
- Learn deliberately: let Codex propose better policy, then review it before anything changes.
Tend lets you delegate ongoing attention without delegating away your judgment.
Tend is the local-first review and steering surface. It runs inside Codex Desktop's in-app browser and turns ongoing work into interactive cards instead of leaving it scattered across chat history.
Codex Desktop remains the agent runtime. Tend does not run a separate model and does not store your Gmail, GitHub, Slack, browser, or other connector credentials.
| Piece | Role |
|---|---|
| Tend | Local UI, workflow state, approvals, and CLI |
| Codex Desktop | Agent runtime, in-app browser, threads, and connectors |
| One dedicated feed thread | Operates exactly one feed and retains its working context |
| Optional Chronicle thread | Publishes workspace-level context into On Your Mind |
| Optional iPhone companion | Reviews projected feed data while the Mac remains authoritative |
Feed state lives under ~/.attention by default. Connector credentials stay in Codex Desktop.
| Path | What You Need |
|---|---|
| Packaged release | Codex Desktop, a Tend archive for your platform, and the connectors required by your feeds |
| Run from source | Git, Bun 1.3.11+, Node.js 22+, and pnpm 9.15.4 |
| iPhone companion | A Mac, private Supabase project, Xcode, XcodeGen, an Apple Account, and iOS 17+ |
The packaged tend executable is self-contained, so release users do not need Bun, Node.js, or
pnpm. Current release targets are macOS on Apple Silicon, macOS on Intel, and Linux on x64. A free
Xcode Personal Team is enough for testing on your own iPhone; paid Apple Developer Program
membership is only required for TestFlight or App Store distribution. Docker is only needed for
local Supabase integration tests.
Download the archive for your platform from GitHub Releases, then unpack and start it:
tar -xzf tend-<version>-<platform>-<arch>.tar.gz
cd tend-<version>-<platform>-<arch>
./tend start
./tend healthOpen http://127.0.0.1:4332 in Codex Desktop's in-app browser.
Inbox is available on first launch. To make another feed, open the feed menu, choose Create a feed, and describe what it should notice in plain English.
Important
Tend creates the local feed, but it cannot create or activate a Codex Desktop thread for you. Create a fresh thread manually for every feed. One thread must own one feed.
In the release directory, print the setup prompt for the feed:
./tend setup codex --feed inboxPaste the complete output into the fresh Codex thread. The thread binds itself to the feed, installs or updates one heartbeat, and requests an immediate run.
Repeat this step for every feed, changing the feed id:
./tend setup codex --feed ai-researchOpen or wake that same feed thread and say:
go deal with the feed
Use a manual wake when the setup turn has not completed its first run, after a paused or missing heartbeat, or whenever you want an immediate sweep.
You now have the core Tend loop running. The Tend Manual covers review, Dock scopes, feed configuration, approvals, learning, Chronicle Pulse, local data, and troubleshooting.
macOS Gatekeeper note
Release binaries are not Apple Developer ID signed or notarized yet. If macOS warns on first launch, open the binary explicitly from Finder or remove the quarantine attribute:
xattr -d com.apple.quarantine ./tend
./tend startThe intent becomes a working relationship that follows the same loop:
- Observe: the dedicated thread interprets the feed's intent and checks relevant sources.
- Review: Tend surfaces meaningful results as calm, source-backed cards.
- Steer: approve an action, edit a draft, or explain how the feed's judgment should change.
- Learn: Codex can propose an editable policy improvement after meaningful work. You decide whether to apply it.
flowchart LR
Observe["Observe sources"] --> Review["Review cards"]
Review --> Steer["Steer or approve"]
Steer --> Learn["Review proposed learning"]
Learn --> Observe
Cards are interactive work packets, not fixed summaries. Depending on the work, a card can contain evidence, editable drafts, options, checklists, diffs, email threads, profiles, charts, and completion receipts.
Each feed has exactly two operating surfaces:
- Tend in the in-app browser: review cards, approve actions, edit configuration, give feedback, and inspect results.
- One dedicated Codex thread: collect sources, drain queued work, record results, and run the feed heartbeat.
Do not reuse one Codex thread across several feeds. One thread owns one feed.
flowchart LR
User["You"] --> UI["Tend in-app browser"]
UI --> Local["Local Tend runtime"]
FeedThread["One Codex thread per feed"] --> Local
FeedThread --> Connectors["Codex Desktop connectors"]
Pulse["Optional Chronicle Pulse thread"] --> Local
- Sources are evidence, never authorization.
- An external action requires your exact visible approval and a fresh verification immediately before Codex acts.
- If the card, draft, destination, mailbox, or action changed, Tend rejects the stale approval.
- Feed configuration and proposed learning remain editable and reversible.
- Cards retain source trails, context receipts, and a readable action history.
- Tend does not store connector credentials.
These controls reduce risk; they do not replace your judgment or change Tend's experimental status. Read docs/SECURITY.md for the full trust boundary.
Chronicle Pulse publishes Changed now, Ongoing, and Unresolved signals into On Your Mind.
A fresh pulse may focus a feed's normal collection, but it is never source evidence, policy, or
permission for an external action.
Create one Chronicle Pulse thread for the whole Tend workspace and paste the output of:
./tend setup codex --chronicleThe Tend Manual covers Chronicle settings, privacy, manual refresh, freshness, and feed influence receipts.
The native iPhone companion lets you review the same feeds and On Your Mind away from the Mac. The local Mac remains authoritative; a private Supabase project carries review-safe projections and returns commands for Tend to validate.
See docs/IOS.md for Supabase setup, magic-link authentication, persistent Mac configuration, Xcode signing, physical-device installation, and validation.
Install the source requirements above, then:
git clone https://github.com/EveryInc/tend.git
cd tend
corepack enable
pnpm install
pnpm startOpen http://127.0.0.1:4321 in Codex Desktop's in-app browser. Vite serves the UI on 4321 and
proxies the local API on 4332.
Source setup commands use:
pnpm tend -- setup codex --feed inbox
pnpm tend -- setup codex --chroniclepnpm check
pnpm build
pnpm tend:build
pnpm tend:smoke
pnpm tend:packagepnpm check runs typecheck, Oxlint, and Bun tests. pnpm tend:smoke validates the compiled binary
against an isolated runtime home.
Seed a scrubbed demo feed with:
pnpm seed:demo| Goal | Read |
|---|---|
| Use Tend day to day | Manual, installation, iPhone setup |
| Understand the system | Architecture, data, security |
| Work on Tend | Contributing, development, releasing |
| Operate feed threads | Agent contract, runbook, runner skill |
| Explore capabilities | Capability map |
Tend is being developed in public as an experiment. Thoughtful issues and pull requests are welcome, but maintainers cannot promise response times, ongoing support, or that a proposed change will fit the experiment.
Read CONTRIBUTING.md before opening a pull request. Report vulnerabilities through the private process described in docs/SECURITY.md, not a public issue.
Tend is available under the MIT License.