What Is Mallard? The Beginner's Guide to Git for AI Agent Sessions

CodexFuse Team · 2026-11-06T00:52:38.026Z · 21 min read min read

What Is Mallard? The Beginner's Guide to Git for AI Agent Sessions

Mallard is a free, open-source desktop app that treats AI agent sessions the way Git treats code. If you searched "what is Mallard AI agents", the short answer is this: pick a Claude Code or Codex session, push it to storage you control, and pull it back on another machine with its original context intact. The app appeared on Hacker News on 3 November 2026 under the tagline "Git for AI agents", and it is built for developers who spend their working day talking to Claude and Codex and want those conversations to travel.

Mallard stores each version as files named by their SHA-256 hash, the same idea behind a SHA-256 hash generator, and it asks nothing more of storage than List, Put and Get. This guide explains what Mallard is, how push and pull work, where sessions live, and what it cannot do yet. It runs on macOS and Windows, and like VPS hosting, it is a tool you operate yourself rather than a service that holds your data for you.

What is Mallard, exactly?

Mallard is a free, MIT-licensed desktop app for macOS 12 and newer and Windows x64 that pushes and pulls Claude Code and Codex sessions like Git commits. Its own tagline is "Git for AI agents", and the README puts it this way: "Your code travels with Git. Your Codex and Claude sessions travel with Mallard." Linux is not supported, and nothing in the sources fetched for this guide mentions a mobile app.

The Mallard app solves a narrow problem. Agent conversations hold the ideas, designs and decisions behind your work, but they usually stay on one machine, with no backup and no easy way to share them. Mallard gives those conversations a push and a pull, so a teammate can read them or pick up where you left off, and so your other laptop can resume a session your busy laptop started.

Two name traps need clearing up once, here at the start. The duck is the brand mascot, not a separate product: the project talks about a "flock", and its public demo is a duck-themed Iliad. "Agent Mallard" is something else entirely, an air-traffic-control research agent from the University of Exeter and NATS described in a January 2026 paper, with no connection to this app.

Why do agent sessions need sharing at all?

Claude Code and Codex both keep their conversations on the machine where they happened. Claude Code offers claude --resume to restore a conversation, but the transcript stays on your local machine, and the docs describe resume as a local feature, not a sync feature.

Codex offers codex resume to reopen a recent chat from the current repository or search across local chats. Neither tool, in the documentation fetched for this guide, offers a way to move a session to another computer.

That gap is what Mallard fills. To share Claude Code sessions today, a developer would otherwise copy session files by hand, paste long transcripts into a chat, or start over and re-explain the whole task. Each of those workarounds loses something: the copied file may not resume cleanly, the pasted transcript loses tool calls and file state, and starting over burns tokens and time.

The need grows once a team is involved. A pull request shows what changed, but the conversation behind it shows why it changed, and a reviewer who can read that conversation can judge the change faster.

Mallard's own framing for this is blunt: "The diff shows what. The chat shows why."

How does Mallard work under the hood?

Mallard works like a small, purpose-built version of Git that was reworked to run on plain cloud storage. The makers say they built "a lightweight version of GIT and reworked our storage protocol, removing CAS so Mallard can work with any cloud storage that supports LIST and PUT APIs". There is no Git server involved, and no expensive sandbox is required.

A push only adds, and it lands in a fixed order. Files named by their SHA-256 hash go up first, then a manifest, then one small record.

Until that record lands, the version does not exist, which means a half-finished push never looks like a version. The listing itself is the history: each record names its parent, and you follow them from the root to the current version.

Two pushes that land in the same seconds are resolved simply. The earlier one wins, and the other is told to compare again before it can proceed.

A pull applies the version it reviewed, even after a newer push has landed, so you always get exactly the version you looked at. Sign-ins, backups and logs never go to storage at all.

The app itself is built with Tauri 2 and a Rust backend, with a React 19 and TypeScript frontend, and its machine-local state lives under a ~/.mallard folder on your computer. That stack description comes from the project's technical report, which is dated 8 September 2026 and describes app version 0.1.2, so it is background on the architecture rather than a statement about the current version 1.0.5.

How do I push and pull a session?

Getting started with Mallard Claude Code sessions takes three moves, and then push and pull follow the same review-first pattern. The README lists the setup as: add a storage, add a project, then push and pull. Here is the fuller flow, with the review step the app insists on.

Add a storage. Pick where your sessions will live: Mallard Cloud, a folder on your computer, a Cloudflare R2 bucket, or Dropbox. One-click sign-in is offered for Dropbox and Cloudflare R2.
Add a project. Pick a folder where Codex or Claude worked. Mallard reads the sessions that belong to that folder.
Review before you push. Mallard compares local sessions with what storage already holds and shows each session as local-only, storage-only, ahead, synchronized, or in conflict. You pick which sessions to push.
Push. The selected sessions go up as SHA-256-named files, then a manifest, then one small record. A push only adds, so it never rewrites what is already stored.
Pull on the other machine and resume. On your other laptop, or your teammate's machine, review the same comparison, pull the sessions you want, and resume them with claude --resume or codex resume, with the original context.

Nothing is pushed or pulled without that review step. You decide which sessions go up and which come down, every time, and Mallard creates backups and keeps result receipts when it pulls.

Where do my sessions actually live?

Your sessions live in storage you connect, not on a Mallard server by default. That is the single most important fact about the app's design, and it is worth stating plainly: unless you choose Mallard Cloud, Mallard holds nothing of yours on its own servers. Your storage credentials stay on your computer, and you review and select sessions before anything is transferred.

Storage option	What it is	What to know
Mallard Cloud	The optional hosted option	Adds GitHub sign-in and a website where your team reads sessions; uploads are private to you and invited people; no price or free-tier limit was stated in any source fetched for this guide
A local folder	A folder on your computer or a mounted drive	The simplest option for one machine's backups, or for a shared drive a team already mounts
Cloudflare R2	Your own R2 bucket	One-click sign-in is offered; you pay whatever R2 charges, not Mallard
Dropbox	Your own Dropbox account	One-click sign-in is offered; sessions travel as ordinary files in your Dropbox

Mallard needs only three things from any of these: List, Put and Get. That is the whole storage contract, and it is why the app can work with a plain folder as happily as with a cloud bucket. The docs also list Feishu Drive as a storage option, but the README's list is the four above, and Feishu appears only in the docs, so this guide treats the four as the safe list.

One more privacy detail matters. Mallard offers a "Credential redaction" setting under Settings and then Privacy, which hides detected keys in chats before transfer. It is optional and off by default, so it only protects you if you turn it on.

How are sessions matched to Git commits?

Each session is placed on exactly one first-parent commit of the branch you select. The rule, from the project's design document, is that a session sits under the closest commit at or after the session's last user input. Placement uses time only, and sessions with no later commit are listed under "Uncommitted".

That mapping is what makes the "better PR" use case work. A reviewer can open a commit, see the session that produced it, and read the discussion and design decisions behind the diff, instead of guessing why a change was made. The project's own public examples show the idea in action: one Mallard Cloud page holds the sessions behind a Git project, another holds the sessions and files of a folder without Git, and a third is a Codex desktop pet ready to pull.

The mapping also explains the name. The name Mallard Git for AI agents is literal here: your code travels with Git, and your sessions travel with Mallard, mapped onto the same commit history your code already has.

What else can Mallard share besides sessions?

Mallard shares more than chat transcripts. It also shares Codex and Claude skills, and Codex pets, pushed and pulled like sessions.

In a Git project it does not upload your code: the README is explicit that "your code travels through Git, as always; Mallard moves the sessions". In a folder without Git, you can tick ordinary files to travel too.

Those non-Git files have size limits, and the limits are worth knowing before you push a large folder. The defaults come from the project's features document.

Limit	Value	What it means
Largest project file	512 MiB by default, up to 1.5 GiB in settings	The biggest single file you can include in a push
Chunk size	32 MiB	Files over 32 MiB are stored as 32 MiB chunk objects
Total selected push	512 MiB, or the setting when larger	The cap on everything you push in one go

The chunk arithmetic is simple and checkable. A 512 MiB file splits into 16 chunks of 32 MiB, and a 1.5 GiB file, which is 1,536 MiB, splits into 48 chunks. Session summaries and previews are parsed locally, with metrics for start and end times, user turns, tokens, agent messages and tool calls, so the app can show you what a session contains before you push it.

How do I resume a session after pulling it?

You resume a pulled session with the same commands you already use, whether you sync Codex sessions or Claude Code ones, because Mallard hands the session back to the agent that made it. For Claude Code, that is claude --resume, which restores a conversation whose transcript stays on your local machine. For Codex, that is codex resume, which reopens a recent chat from the current repository or searches across local chats.

# Resume a pulled session in Claude Code
claude --resume

# Resume a pulled session in Codex
codex resume

# Load the most recent Claude Code conversation in this directory
claude --continue

If you are still learning the agent itself, our guide on how to use Claude Code walks through the commands, including resume and continue, before you add Mallard on top. Two platform notes apply.

On macOS, Claude desktop actions reuse the running app for session resumes. On Windows, CLI actions open Windows Terminal with Windows PowerShell, so you need Windows Terminal installed with its wt.exe app execution alias enabled.

Codex sessions are normally stored under ~/.codex on your machine, including compressed rollout files, according to Mallard's own features document. Claude Code sessions live under ~/.claude/projects/ in per-project folders, according to third-party documentation. No official Anthropic or OpenAI page fetched for this guide states either path directly, so treat the paths as the tools' usual locations, not as documented guarantees.

How does Mallard compare with Ravenry and the other session tools?

Mallard is not the only tool watching agent sessions, but it is the only one in this comparison whose job is to move sessions between machines. The others watch, display or hand off sessions on one machine, and that difference is the whole point of the comparison.

Tool	What it does	Syncs sessions to another machine?	Licence and platforms
Mallard	Pushes and pulls Claude Code and Codex sessions like Git commits, mapped to Git commits	Yes, to a folder, R2, Dropbox or Mallard Cloud	MIT, free; macOS 12+ and Windows x64
Ravenry	A local board that puts every Claude Code and Codex session on your Mac on one page, sorted by what needs you	No, it watches sessions on one machine	Free and open source; macOS with Node 22+, local only, no telemetry
ccdeck	A local dashboard showing every Claude Code and Codex session, subagents, tool calls, cost and quota left	No, it is an instrument panel for one machine	AGPL-3.0, free; desktop app for macOS, Windows and Linux
Claude Code UI	A web interface that manages Claude Code, Cursor CLI and Codex sessions from any device	No, it wraps the CLIs in a browser UI	Open source; discovers sessions from the local machine
agent-sessions-cli	Shares coding-agent sessions with a team through the Git repo you already work in	Partly, as handoff files committed into the repo	Open source; holds written handoffs, not full resumable sessions
Session Relay	A plugin that lets Claude Code sessions see each other, message each other and avoid colliding Git pushes	No, it coordinates sessions on one machine or a small self-hosted relay	MIT; the dimitrihilverda plugin, not the unrelated SessionRelay memory tool

Ravenry is the closest sibling, and it is worth a closer look, because our own post on what Ravenry is covers it in full. Ravenry is a board, not a sync tool: it watches sessions and sorts them by what needs your attention, on one Mac, over localhost.

Mallard is the opposite move: it does not watch your sessions for you, it moves them. A developer could reasonably use both, one to see what needs attention and one to carry a session to another machine.

The agent-sessions-cli entry is the closest rival to Mallard's idea, and the difference is instructive. It commits session handoffs as files into the Git repo itself, in a .claude/sessions/ folder, so a teammate can read them.

Mallard instead stores the full session in separate storage and lets the teammate pull it and resume it with the original context. One shares a written handoff, the other shares the resumable session.

One naming caution applies to the last row. "Session Relay" is also the name of at least two unrelated session tools, including an MCP session-memory tool that stores sessions in local SQLite. The comparison above is the dimitrihilverda plugin only, and any other tool with the same name is a different product.

What does Mallard cost?

The Mallard app is free, and the FAQ in its README says so without qualification: "Yes. The Mallard app is free and open source under the MIT License: use it, change it and share it, at work or at home." The licence file confirms it: "MIT License, Copyright (c) 2026 Mallard contributors".

The Show HN post says Mallard lets teams "achieve the same goal at almost zero cost, without any cloud VMs", comparing it with Anthropic's internal setup, where teams use cloud VMs and Claude Tag to share agent conversations. That phrase is the maker's, not a measured fact. Storage still costs whatever its provider charges, whether that is a Cloudflare R2 bucket or a Dropbox plan, and no price or cost measurement was published in any source fetched for this guide.

Mallard Cloud's price is simply unstated. No price, free-tier limit or availability page was found in any fetched source, and the app is described only as free with Mallard Cloud as an optional extra.

Do not assume Mallard Cloud is free, paid, or limited in any particular way. CodexFuse does not offer a Mallard tool, so this guide is an explainer about someone else's app, not a product page.

What are Mallard's limits?

Mallard is early software, and its limits are easy to list. It runs on macOS 12 and newer, on Apple silicon and Intel, and on Windows x64.

There is no Linux build: the version 1.0.5 release offers macOS disk images and archives and a Windows installer, and nothing else. Nothing fetched for this guide mentions a mobile app either.

The project is small and young. Its repository was created on 22 July 2026, which makes it 107 days old on the date of this article, and it had 110 stars, 4 forks and 2 open issues when checked on 6 November 2026.

That works out to about one star a day, which is a small, early project, not a popular one. The latest release, version 1.0.5, was published on 27 October 2026, ten days before this article, and the version 1.0 line moved from 1.0.0 on 18 October to 1.0.5 on 27 October, nine days for five patch releases.

The public launch was quiet. The Show HN post of 3 November 2026 had 3 points and 2 comments at the time of checking, and both comments were by the maker, so do not describe Mallard as taking off on Hacker News.

The only independent coverage found was a single short VibeHacker summary on 4 November 2026, one day after the launch post. No review, benchmark or hands-on test was found in any search run for this guide.

Two more gaps are worth naming. No fetched source says whether Mallard encrypts session data at rest or in transit, so this guide claims nothing about encryption.

No fetched source says whether a session pulled on Windows resumes identically to one pushed from macOS, so cross-OS resume is unconfirmed. The release cadence is brisk, with 12 releases in the 35 days from 22 September to 27 October 2026, about one every three days, which is a sign of active development and also a sign that the app is still changing fast.

Is Mallard worth trying?

Mallard is worth trying if you already live in Claude Code or Codex on more than one machine, or if your team reviews pull requests and wants the reasoning behind them. The cost of trying is low: the app is free and MIT-licensed, your storage is your own, and your code never travels through Mallard at all. The setup is three moves, add a storage, add a project, push and pull, and the review step means nothing moves without you choosing it.

You should wait if you work on Linux, since there is no build for it, or if you need a sync tool with independent reviews, published security claims, or a support channel. You should also wait if you want a managed cloud service that holds everything for you, because Mallard is the opposite by design: you bring the storage, and it only holds the sessions you choose to share. The Model Context Protocol is a useful comparison here, because it too is a piece of plumbing that connects tools rather than a service that holds your data, and Mallard belongs in the same category.

The version timeline below is the short history of the project, from the repository's creation to this article, and it shows how fast the app has moved in its first months.

Date	What happened
22 July 2026	Repository created on GitHub, under the Git4Agent organisation
8 September 2026	Technical report written, describing app version 0.1.2
22 September 2026	Version 0.1.4 released, the earliest release in the 12-release run
18 October 2026	Version 1.0.0 released
27 October 2026	Version 1.0.5 released, the latest version at the time of writing
3 November 2026	Show HN post, "Mallard: Git for the age of AI agents", by rika321
4 November 2026	VibeHacker publishes the only independent coverage found
5 November 2026	CodexFuse publishes its Ravenry guide, the session-board sibling of this app
6 November 2026	This article, three days after the Show HN post

Mallard's own build story is worth quoting as the maker's words, not as a verified fact: "3 months. 10 accounts on 20× plans.

100 billion tokens later, Mallard finally hatched." The repository dates are consistent with the "3 months" part, since the repo was created 104 days before the Show HN post, but the token count has no supporting evidence in any fetched source. The project was also built for OpenAI Build Week, according to the README footer.

Sources

Every fact in this article comes from a source fetched on 6 November 2026. The Mallard homepage itself could not be quoted: it is a JavaScript app shell whose fetched HTML contains only "Loading Mallard", with no readable marketing copy, so the GitHub README is the primary vendor source instead.

Mallard README, GitHub repository Git4Agent/mallard-app, https://github.com/Git4Agent/mallard-app
Mallard repository data, GitHub API, https://api.github.com/repos/Git4Agent/mallard-app
Mallard releases, GitHub API, https://api.github.com/repos/Git4Agent/mallard-app/releases
Mallard licence file, https://github.com/Git4Agent/mallard-app/blob/main/LICENSE
Show HN: "Mallard: Git for the age of AI agents", Hacker News item 50357605, https://news.ycombinator.com/item?id=50357605
VibeHacker, "Mallard is a free, MIT app that pushes and pulls Claude Code and Codex sessions like Git commits", 4 November 2026, https://www.vibehacker.com/news/mallard-is-a-free-mit-app-that-pushes-and-pulls-claude-code-and-codex-sessions-l
Mallard features document, https://raw.githubusercontent.com/Git4Agent/mallard-app/main/docs/FEATURES.md
Mallard technical report, 8 September 2026, https://raw.githubusercontent.com/Git4Agent/mallard-app/main/TECHNICAL_REPORT.md
Mallard Git session mapping design document, https://raw.githubusercontent.com/Git4Agent/mallard-app/main/docs/DESIGN_GIT_SESSION_MAPPING.md
Claude Code CLI reference and common workflows, https://code.claude.com/docs/en/cli-reference.md and https://code.claude.com/docs/en/common-workflows.md
OpenAI Codex CLI documentation, https://developers.openai.com/codex/cli/
"A Future Capabilities Agent for Tactical Air Traffic Control", arXiv:2601.04285, https://arxiv.org/abs/2601.04285v1
CodexFuse, "What Is Ravenry?", 5 November 2026, https://codexfuse.dev/blog/what-is-ravenry
ccdeck, https://ccdeck.dev/
Session Relay plugin, https://mcpservers.org/servers/dimitrihilverda/claude-session-relay
Claude Code UI, https://github.com/siteboon/claudecodeui
agent-sessions-cli, https://pypi.org/project/agent-sessions-cli/

Frequently Asked Questions

Is Mallard free?

Yes. The Mallard app is free and open source under the MIT License, and the README says you can "use it, change it and share it, at work or at home".

Your storage is separate: a folder costs nothing, while a Cloudflare R2 bucket or a Dropbox plan costs whatever that provider charges. Mallard Cloud is described only as optional, and no price for it was stated in any source fetched for this guide.

Does Mallard upload my code?

No. In a Git project, your code travels through Git, as always, and Mallard moves only the sessions.

In a folder without Git, you can tick ordinary files to travel too, but that is your choice, and files are capped at 512 MiB by default, up to 1.5 GiB in settings. You also review and select sessions before anything is transferred.

Can I use my own storage instead of Mallard Cloud?

Yes, and Mallard Cloud is optional by design. You can use a folder on your computer or a mounted drive, your own Cloudflare R2 bucket, or your Dropbox account.

Mallard needs only List, Put and Get from storage, and your storage credentials stay on your computer. Mallard Cloud adds GitHub sign-in and a website where your team reads sessions.

Which agents does Mallard support?

Codex and Claude Code, in the terminal or in their desktop apps. Pulled sessions resume with claude --resume or codex resume, with the original context. There is no support for other agents in the sources fetched for this guide, and sessions are mapped to Git commits only in projects that use Git.

Is Mallard the same as Agent Mallard?

No. Agent Mallard is a research agent for air-traffic control from the University of Exeter and NATS, described in a January 2026 paper, and it has no connection to this app. The Mallard in this guide is a free, MIT-licensed desktop app for sharing Claude Code and Codex sessions, and the duck is its brand mascot.