MarsDawn On the Mac App Store

Anthropic says agents should be transparent — so who reads what they lay out?

In December 2024 Anthropic published “Building Effective Agents,” a guide for people who build AI agents. Its summary lists three principles, and one of them is transparency. This post is about the other end of that principle: once an agent lays out its steps, somebody has to read them.

Transparency is something the agent does. Reading is something you do. Anthropic asks builders to show an agent's planning steps; for most people driving a coding agent, those steps arrive as a Markdown file that someone has to read at the right moment.

What the guide says

Erik S. and Barry Zhang sum up their advice like this:

“When implementing agents, we try to follow three core principles: Maintain simplicity in your agent's design. Prioritize transparency by explicitly showing the agent’s planning steps. Carefully craft your agent-computer interface (ACI) through thorough tool documentation and testing.”

These are design principles for people who build agents, not instructions for the person using one. The principle asks for the steps to be shown. It doesn't say who reads them.

The same post describes what an agent does once it has a task: “Once the task is clear, agents plan and operate independently, potentially returning to the human for further information or judgement.” And: “Agents can then pause for human feedback at checkpoints or when encountering blockers.” Look at the verbs, potentially and can. Checkpoints are described as something an agent can have, not something it must.

Most of the checking isn't done by you

It's easy to overstate this, so here's what the guide actually puts first. The agent checks itself against the world: “During execution, it's crucial for the agents to gain “ground truth” from the environment at each step (such as tool call results or code execution) to assess its progress.” In that sentence, ground truth means test results and tool output. It doesn't mean a person.

The guide is also direct about the risk: “The autonomous nature of agents means higher costs, and the potential for compounding errors.” Its answer is extensive testing in sandboxed environments, with guardrails. It doesn't say “read more carefully”.

A person does come in later, in the appendix on coding agents: “However, whereas automated testing helps verify functionality, human review remains crucial for ensuring solutions align with broader system requirements.” That sentence is about code. The gap it points at is familiar from any agent, though: a test can tell you something works, not that it's what you meant.

Where the steps end up

From here on this is our reading, not Anthropic's.

If you use a coding agent day to day, its planning steps usually don't show up in a dashboard. They show up as files: plan.md, a task list with checkboxes, a progress file the agent keeps rewriting, a summary at the end. Transparency, from your side, means more to read.

Showing the steps is the agent's half of the deal. The other half is a person reading them when it matters: before the migration runs, before the branch merges, before “done” is accepted. An agent that lays everything out in a 600-line file nobody opens is transparent on paper and unsupervised in practice.

Harrison Chase made a related point in 2024, writing about how agent frameworks should work rather than about documents: “You’ll want the ability to observe what is going on inside, since the exact steps taken may not be known ahead of time.” He was talking about tooling for the people building agents. If you're the one driving the agent, the plain file it keeps writing is often the part you can watch.

None of these authors mention MarsDawn, and none of them endorse it or any other Markdown tool.

Why that read is harder than it looks

The file is long, and what matters is rarely near the top. The diagram that explains the change is Mermaid source, not a picture (seeing it drawn is covered in How to view a Markdown file on a Mac). The agent may rewrite the file while you're halfway down. There's often more than one file, sometimes on different branches or worktrees. And when you do spot a problem, “the cache part looks off” leaves the agent guessing. The longer version of this is on Reading what your agent hands back.

Where MarsDawn fits, and where it doesn't

MarsDawn is a Mac app for this read. It doesn't make an agent more transparent, and it has no AI model inside: it won't summarize the plan or tell you whether it's right. What it does:

You still do the reading. MarsDawn keeps a long, changing file readable while you do.

Try it

MarsDawn is on the Mac App Store. There's also the free marsdawn command-line tool:

brew install redtear1115/tap/marsdawn

It exports Markdown to PDF without the app.

Command Line · Know before you buy: What MarsDawn doesn't do

Next

Sources