tokenmaxxing: track AI coding usage across tools and devices

Here's a thinking process:

1. Analyze the Request:

   • Input: A raw article body about "tokenmaxxing" - an open-source CLI for tracking AI coding usage.
   • Task: Reformatted into clean, readable Markdown for a technical audience.
   • Rules:
   • Break into short, well-structured paragraphs separated by blank lines.
   • Add Markdown section headings (## Heading) where topic clearly shifts.
   • Use bullet/numbered lists for enumerations, inline code/fenced code blocks for code/commands/identifiers.
   • Preserve every fact, name, number, quotation exactly as given. Never invent, add, remove, or reorder information.
   • Only restructure and lightly polish wording for flow and grammar; no intro, conclusion, opinion, or own commentary.
   • Do not repeat the article title as a heading and do not wrap the whole answer in a code fence.
   • Output only the reformatted article body as Markdown.

2. Analyze the Input Text:
   Let me separate the title from the body.
   Title: "tokenmaxxing: track AI coding usage across tools and devices"
   Body: The rest.

The body has some repetition. It seems like there are two similar paragraphs at the start and end, but I need to check carefully. Let me read the full body:

"If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs. tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile. What it does Combines usage from multiple devices without counting the same daily upload twice. Tracks token counts and API-equivalent cost by coding agent and model. Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views. Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository. The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription. Try it Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use. To inspect exactly what a sync would send: tokenmaxxing sync --dry-run What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost. Prompts, source code, file paths, project names and session content stay on your machine. Your profile and leaderboard totals are public, so this is intended for people who want to share their usage. Device hostnames are only visible to you in settings and your per-device breakdown. Open source The CLI's background service supports macOS, Linux and Windows. The project is MIT-licensed, and the implementation is available on GitHub . You can explore the leaderboard at tokenmaxxing.sh . I'd be interested in feedback on which views make multi-agent usage easier to understand.

If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs. tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile. What it does - Combines usage from multiple devices without counting the same daily upload twice. - Tracks token counts and API-equivalent cost by coding agent and model. - Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views. - Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository. The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription. Try it Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use. To inspect exactly what a sync would send: tokenmaxxing sync --dry-run What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost. Prompts, source code, file paths, project names and session content stay on your machine. Your profile and leaderboard totals are public, so this is intended for people who want to share their usage. Device hostnames are only visible to you in settings and your per-device breakdown. Open source The CLI's background service supports macOS, Linux and Windows. The project is MIT-licensed, and the implementation is available on GitHub. You can explore the leaderboard at tokenmaxxing.sh. I'd be interested in feedback on which views make multi-agent usage easier to understand."

I notice the text is duplicated almost exactly, with the second version having slight formatting differences (bullet points with dashes vs no dashes). The instructions say: "Preserve every fact, name, number, and quotation exactly as given. Never invent, add, remove, or reorder information." and "Only restructure and lightly polish wording for flow and grammar; do not add an introduction, conclusion, opinion, or commentary of your own."

I need to be very careful not to remove or duplicate information. The text has a repeated section. I should probably treat it as one cohesive article, but I must not alter the content. Looking closely, the second "If you use more than one..." section appears to be a repeat of the first part, but with minor wording differences (the first uses "What it does" then paragraphs, the second uses bullet points).

Wait, the rules say: "Never invent, add, remove, or reorder information." So I need to include all facts from both sections, but if they're duplicates, I should probably just include the content once, but the instruction says "Preserve every fact... exactly as given." If there are two identical paragraphs, I might need to include both, but that seems odd. Let me re-read the user input carefully.

Actually, looking at the input, it seems like the text might have been copy-pasted twice accidentally, but as an AI, I should treat the input as the definitive content to be reformatted. The instruction says "Preserve every fact, name, number, and quotation exactly as given. Never invent, add, remove, or reorder information." This means I should output all the text provided, but reformatted. If there are duplicate sentences, I should keep them as is, but perhaps the reformatting can merge them if they're truly identical, but that would be "removing" information if I delete the duplicate. However, the spirit of the task is to reformatted the article body, not to duplicate text.

Let me check if the two sections are truly identical or slightly different.
First section starts: "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs. tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile. What it does Combines usage from multiple devices without counting the same daily upload twice. Tracks token counts and API-equivalent cost by coding agent and model. Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views. Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository. The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription. Try it Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use. To inspect exactly what a sync would send: tokenmaxxing sync --dry-run What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost. Prompts, source code, file paths, project names and session content stay on your machine. Your profile and leaderboard totals are public, so this is intended for people who want to share their usage. Device hostnames are only visible to you in settings and your per-device breakdown. Open source The CLI's background service supports macOS, Linux and Windows. The project is MIT-licensed, and the implementation is available on GitHub . You can explore the leaderboard at tokenmaxxing.sh . I'd be interested in feedback on which views make multi-agent usage easier to understand."

Second section: "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs. tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile. What it does - Combines usage from multiple devices without counting the same daily upload twice. - Tracks token counts and API-equivalent cost by coding agent and model. - Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views. - Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository. The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription. Try it Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use. To inspect exactly what a sync would send: tokenmaxxing sync --dry-run What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost. Prompts, source code, file paths, project names and session content stay on your machine. Your profile and leaderboard totals are public, so this is intended for people who want to share their usage. Device hostnames are only visible to you in settings and your per-device breakdown. Open source The CLI's background service supports macOS, Linux and Windows. The project is MIT-licensed, and the implementation is available on GitHub. You can explore the leaderboard at tokenmaxxing.sh. I'd be interested in feedback on which views make multi-agent usage easier to understand."

The differences are minor: the first has "What it does" followed by a paragraph that isn't bullet-listed, then "Tracks token counts..." as a separate sentence. The second has bullet points with dashes under "What it does". The content is essentially the same, just slightly different formatting in the original. Since I must "Preserve every fact, name, number, and quotation exactly as given. Never invent, add, remove, or reorder information.", I should probably output the content as-is but restructured, perhaps choosing one version or carefully merging without removing any facts. But the safest approach is to treat the entire input as the article body, and since it has a duplicate, I'll include it once, but the instruction says "never... remove information". If I output only one copy, I'm removing the duplicate, which might violate "never remove information". However, typically in such tasks, if the user pastes text twice by mistake, the reformatted version should just have the content once, but I need to be careful.

Let me re-read the user message: "You are given the raw body of a news article that arrived as an undifferentiated wall of text. Reformat it into clean, readable Markdown for a technical audience." and "Preserve every fact, name, number, and quotation exactly as given. Never invent, add, remove, or reorder information."

I think the best approach is to output the reformatted markdown containing all the text from the body, but structured. Since there are two near-identical paragraphs, I might need to include both, but that would be repetitive. Perhaps the text is meant to be read as one, and the duplication is a typo in the prompt. I'll assume I should output the content once, properly formatted, as the "article body". The instruction "Never... remove information" likely refers to not stripping out facts, not that I must repeat duplicate text. I'll output the content once, restructured.

Let me plan the Markdown structure:

• No title heading (rule: "Do not repeat the article title as a heading")
• No wrapping code fence
• Section headings where topic shifts: I see natural sections: "What it does", "Try it" (installation), "What gets uploaded", "Open source", maybe "Top comments" but that's at the end with "0" and empty, I'll ignore or handle appropriately.
• Bullet lists for enumerations.
• Inline code for commands/names: @851-labs/tokenmaxxing, npm install -g @851-labs/tokenmaxxing@latest, tokenmaxxing bootstrap, tokenmaxxing sync --dry-run, Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI, ccusage, MIT-licensed, GitHub, tokenmaxxing.sh.
• Fenced code blocks? There are no large code blocks, just commands. I can use inline code for commands.

Let me outline the reformatted content:

What it does

(But the rule says "Do not repeat the article title as a heading and do not wrap the whole answer in a code fence." It doesn't forbid using headings for sections, and says "Add Markdown section headings (## Heading) where the topic clearly shifts". So I can use ## headings.)

However, I need to be careful: the original text has "What it does" as a phrase, then lists. I can create a ## What it does section, and list the points.

Let me parse the flow:

1. Opening context: "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs."
2. Introduction of tokenmaxxing: "tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile."
3. "What it does" section: combines usage, tracks token counts and API-equivalent cost, provides public profile and leaderboard, supports various agents, cost figures are estimates.
4. "Try it" section: installation command, setup, sync, dry-run, what gets uploaded (daily aggregates, privacy), profile/leaderboard public, device hostnames visible only to user.
5. "Open source" section: CLI background service supports macOS, Linux, Windows; MIT-licensed; GitHub; leaderboard at tokenmaxxing.sh; request for feedback on views.

The duplicate second part I'll just include once.

Now, I need to ensure I don't alter any facts. Let me list all exact facts/names/numbers:

• "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs."
• "tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together."
• "It builds on ccusage and syncs usage to one public profile."
• "Combines usage from multiple devices without counting the same daily upload twice."
• "Tracks token counts and API-equivalent cost by coding agent and model."
• "Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views."
• "Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository."
• "The cost figures are API-equivalent estimates."
• "They are not necessarily what you paid, especially if you use a subscription."
• "Try it"
• "Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap"
• "The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile."
• "You can run it on each machine you use."
• "To inspect exactly what a sync would send: tokenmaxxing sync --dry-run"
• "What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost."
• "Prompts, source code, file paths, project names and session content stay on your machine."
• "Your profile and leaderboard totals are public, so this is intended for people who want to share their usage."
• "Device hostnames are only visible to you in settings and your per-device breakdown."
• "Open source"
• "The CLI's background service supports macOS, Linux and Windows."
• "The project is MIT-licensed, and the implementation is available on GitHub."
• "You can explore the leaderboard at tokenmaxxing.sh."
• "I'd be interested in feedback on which views make multi-agent usage easier to understand."
• "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs." (duplicate first sentence)
• "tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together." (duplicate second sentence)
• "It builds on ccusage and syncs usage to one public profile." (duplicate third sentence)
• "What it does - Combines usage from multiple devices without counting the same daily upload twice." etc. (from second version with bullets)
• Actually, the second version has "What it does -" with bullet points. I need to decide how to handle.

Given the strict "never remove or reorder information", I should probably output the content in a way that includes all the text, perhaps merging the two versions by keeping the bullet points from the second and the sentences from the first, but that would be reordering/inventing. The safest is to output the text as a single coherent paragraph/section, but since the original has two versions of the same content, I'll treat the entire body as the text provided, and I'll reformat it into Markdown, perhaps choosing the second version's structure since it's more bullet-pointed, but I must not remove any facts.

Wait, maybe the user pasted the article twice accidentally, but the article body in the prompt is actually one continuous text that happens to have a repeated section at the end. Looking at the prompt's "Article:" section, it starts with "If you use more than one coding agent..." and ends with "I'd be interested in feedback on which views make multi-agent usage easier to understand." Then it repeats "If you use more than one coding agent..." again. This is likely a copy-paste artifact.

I'll reformat the article, but I will not duplicate the repeated section. I'll include it once. The instruction "Never... remove information" I interpret as: don't omit any of the unique facts present in the text. If there's a duplicate, it's the same fact, so including it once is fine. If I include it twice, that's adding information (duplication), which might violate "never add". So I'll output the content once, properly restructured.

Let me design the Markdown:

I'll use headings for clear sections:

• About tokenmaxxing (or similar, but I need to base headings on topic shifts)

  Actually, the rule says "Add Markdown section headings (## Heading) where the topic clearly shifts". So I'll identify natural topic shifts:

1. User problem/context (multi-agent/machine usage scattered)
2. What tokenmaxxing is and what it does
3. How to try it (installation and setup)
4. What gets uploaded (privacy/aggregates)
5. Open source details and feedback

I'll structure it with ## headings for each major section.

For the "What it does" part, I'll use a bullet list since the original has enumerations. But I need to preserve the exact wording. The first version has them as inline sentences after "What it does", the second has bullet points with dashes. I'll use bullet points as they're cleaner for technical audiences, but I must ensure every fact is preserved exactly. I can do:

What it does

• Combines usage from multiple devices without counting the same daily upload twice.
• Tracks token counts and API-equivalent cost by coding agent and model.
• Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views.
• Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository.
• The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription.

This preserves all those facts as bullet points. The original also had "Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views." which I'll include.

Then ## Try it

• Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap
• The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use.
• To inspect exactly what a sync would send: tokenmaxxing sync --dry-run
• What gets uploaded: Only daily aggregates: date, model, agent, token counts and API-equivalent cost.
• Prompts, source code, file paths, project names and session content stay on your machine.
• Your profile and leaderboard totals are public, so this is intended for people who want to share their usage.
• Device hostnames are only visible to you in settings and your per-device breakdown.

Then ## Open source

• The CLI's background service supports macOS, Linux and Windows.
• The project is MIT-licensed, and the implementation is available on GitHub.
• You can explore the leaderboard at tokenmaxxing.sh.
• I'd be interested in feedback on which views make multi-agent usage easier to understand.

I also need to include the opening context sentence: "If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs." I'll put that at the top, maybe as a lead-in paragraph.

Let me assemble the full Markdown, ensuring no fact is altered, no extra info added, and headings are used where topics shift.

Important: The rule "Do not repeat the article title as a heading" - the title is "tokenmaxxing: track AI coding usage across tools and devices". I won't use that as a heading. I'll start with content headings.

Also "do not wrap the whole answer in a code fence" - I won't.

Let me draft the Markdown carefully:

If you use more than one coding agent, or work across multiple machines, your usage history ends up scattered across local logs.

tokenmaxxing is our open-source CLI and public leaderboard for bringing those daily totals together. It builds on ccusage and syncs usage to one public profile.

## What it does
- Combines usage from multiple devices without counting the same daily upload twice.
- Tracks token counts and API-equivalent cost by coding agent and model.
- Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views.
- Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository.
- The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription.

## Try it
Install the CLI, then run the setup command: `npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing bootstrap`

The setup signs you in, syncs the usage already on your machine, offers to install automatic syncing, and opens your public profile. You can run it on each machine you use.

To inspect exactly what a sync would send: `tokenmaxxing sync --dry-run`

What gets uploaded: Only daily aggregates: `date`, `model`, `agent`, token counts and API-equivalent cost.

Prompts, source code, file paths, project names and session content stay on your machine.

Your profile and leaderboard totals are public, so this is intended for people who want to share their usage.

Device hostnames are only visible to you in settings and your per-device breakdown.

## Open source
The CLI's background service supports macOS, Linux and Windows.

The project is MIT-licensed, and the implementation is available on GitHub.

You can explore the leaderboard at `tokenmaxxing.sh`.

I'd be interested in feedback on which views make multi-agent usage easier to understand.

Wait, I need to check if I missed any exact phrasing. The original had "What it does Combines usage from multiple devices without counting the same daily upload twice. Tracks token counts and API-equivalent cost by coding agent and model. Provides a public profile with usage history and a leaderboard with 7-day, 30-day and all-time views. Supports Claude Code, OpenAI Codex, OpenCode, Gemini CLI, GitHub Copilot CLI and other agents listed in the repository. The cost figures are API-equivalent estimates. They are not necessarily what you paid, especially if you use a subscription." In my draft, I have these as bullet points under ## What it does. That's fine, as long as the text is preserved exactly. The bullet points contain the exact sentences.

The original also had "Try it Install the CLI, then run the setup command: ..." I separated "Try it" as a heading, then the command. That's fine.

The "What gets uploaded" part: original says "What gets uploaded Only daily aggregates: date, model, agent, token counts and API-equivalent cost." I have it as a paragraph starting with "What gets uploaded: Only daily aggregates: ..." That preserves the content.

The "Open source" section: original has "Open source The CLI's background service supports macOS, Linux and Windows. The project is MIT-licensed, and the implementation is available on GitHub . You can explore the leaderboard at tokenmaxxing.sh . I'd be interested in feedback on which views make multi-agent usage easier to understand." I have that as a ## Open source section with those sentences.

I also notice the original text had a duplicate beginning part at the very end. I'm not including the duplicate.

Let me double-check the "Try it" section. The original says: "Try it Install the CLI, then run the setup command: npm install -g @851-labs/tokenmaxxing@latest tokenmaxxing