ax
Local-first observability and feedback loop for coding agents.
Tagline
Fix repeated agent mistakes automatically
The missing feedback layer for coding agents
Local observability for agent workflows, not dashboards
Stop fixing the same agent mistake twice
ax is the missing feedback layer between your coding agent and your codebase.
The page repeatedly frames ax as the 'agent experience layer' and 'the missing layer,' which makes it strongest as a new category rather than a point tool.
The local, forkable alternative to black-box agent observability tools.
Local-first, AGPL-3.0, typed end to end, and SurrealDB on localhost are strong differentiators versus cloud-first products like LangSmith-style observability or vendor-hosted agent analytics.
Stop fixing the same agent mistake twice.
The clearest pain on the page is repeated failure patterns; the product is built around detecting repeats and turning them into one-by-one reviewed fixes, which is a sharper value prop than generic monitoring.
Primary user
Engineer or platform-minded developer using Claude Code or other coding agents daily in a real codebase
ICP #1
Staff engineer building agentic developer workflows inside a fast-moving product team
Pain
Their coding agent keeps making the same mistakes across sessions, but the failure patterns are buried in transcripts and impossible to systematize.
Why this solves
ax turns raw sessions into a local graph, surfaces repeats, and proposes concrete repo-specific fixes they can approve instead of manually hunting through logs.
ICP #2
Solo founder or indie hacker using Claude Code to ship features quickly
Pain
They don't have time to babysit the agent or re-debug the same harness issues every week, and each failure costs momentum.
Why this solves
ax gives them a lightweight terminal-first feedback loop, plus Harness Doctor scoring, so their agent setup improves as they work.
ICP #3
Developer productivity lead at an AI-native startup standardizing how engineers use coding agents
Pain
They need evidence of what practices spread, what gets stuck, and where the team’s AI workflow is degrading without relying on anecdotes.
Why this solves
ax for teams is positioned explicitly around team-level evidence, spread/stuck patterns, and standardizing practices from captured agent sessions.
Strengths
- +The product is unusually concrete: it shows live terminal-style examples, actual counts like '4,773 sessions' and '369k turns indexed,' and specific commands like 'ax retro emit' and 'ax retro reflect.'
- +The local-first and forkable positioning is strong and credible because it is reinforced by the architecture details: SurrealDB on 127.0.0.1, typed graph, AGPL-3.0.
- +The Harness Doctor concept is memorable and gives the product a visible outcome beyond raw logging.
Weaknesses
- −The homepage is jargon-dense: 'typed local graph,' 'safety-contracted,' 'brief-only,' and 'six forms' are meaningful only after comprehension work.
- −It buries the actual user job-to-be-done under clever phrasing; a new visitor may not immediately understand whether this is observability, workflow automation, evals, or prompt management.
- −The product seems to have two audiences on one page - individual agent users and teams - and the transition between them is abrupt.
- −There is no obvious screenshot of the dashboard or a single before/after story showing how a repeated mistake becomes a fix.
- −The value of 'interventions' is abstract; the page says ranked and accepted, but not what a typical intervention looks like in plain language.
Fix these
- Lead with a plain-English promise above the fold: 'Find and fix the mistakes your coding agent keeps repeating.'
- Add one end-to-end walkthrough with a real failure, the retro output, the ranked proposals, and the applied fix.
- Create separate messaging paths for solo developers and teams so the landing page doesn't try to sell both at once.
- Replace some internal terminology with outcome language, then define the internal terms deeper in the page.
- Show a dashboard screenshot and a sample intervention card so visitors immediately understand what they are buying.
Drop-in replacement copy
Headline
Find repeated agent mistakes.
ax turns coding sessions into fixes your agent can learn from next run.
See what your agent keeps getting wrong
ax watches Claude Code and Codex sessions, then finds the mistakes that repeat across runs. Instead of scanning transcripts by hand, you get the pattern immediately.
Turn failures into small repo-specific fixes
When ax detects a repeat, it proposes brief interventions you review before applying. That keeps the loop safe, local, and tied to the actual codebase.
Know whether the harness is the problem
Harness Doctor scores your setup and workflow health so you can tell if the issue is the agent, the repo, or the harness itself. It makes debugging less guessy.
Keep the whole feedback loop on your machine
Sessions, events, and the typed graph live locally on 127.0.0.1 with SurrealDB. That means more control, easier inspection, and no black-box observability vendor.
FAQ
Is ax a log viewer?
No. It ingests sessions, detects repeated mistakes, and proposes fixes. The goal is to improve the next run, not just archive the last one.
Does it work with Claude Code and Codex?
Yes. ax supports session sources from Claude Code and Codex, plus git and hook events.
Does my data leave my machine?
By default, no. ax is local-first and backed by a local SurrealDB graph on 127.0.0.1.
What is a Harness Doctor score?
It’s a simple health check for your agent workflow. It helps you see whether the setup itself is causing the repeated failures.
What does an intervention look like?
A short, repo-specific fix like a skill, guidance, subagent, hook, automation, or harness check. You review each one before applying it.
ax watches Claude Code/Codex sessions, finds the repeats, and turns them into small repo-specific fixes you review before applying. No more scrolling transcripts looking for the same failure for the 12th time.
Built ax because coding agents got fast before they got better. It indexes sessions into a local graph, grades harness health, and proposes fixes when the same mistake shows up again. 127.0.0.1 > black-box SaaS.
One thing kept showing up in agent runs: the same mistakes, over and over. So I built ax to turn transcripts into a typed local graph, then rank the interventions that actually improve the next run. It’s basically a feedback loop for coding agents.
1. Agent session goes off the rails. 2. ax indexes the transcript locally. 3. Repeat mistake gets detected. 4. Harness Doctor scores the setup. 5. You review one small fix and apply it. That’s the loop. Not another log viewer.
Agent tooling is flooded with dashboards. What I wanted was simpler: show me what the agent keeps doing wrong, rank the fixes, and keep the data on my machine. ax does that with a local SurrealDB graph and reviewed interventions.
If you’re still hunting through agent logs by hand, you’re doing archaeology. ax turns sessions into a graph, surfaces repeated mistakes, and gives you brief fixes you can accept one at a time.
Harness Doctor in ax scores how healthy your coding-agent setup is. It flags weak spots in the workflow, shows what skills are being used, and points to the smallest fix with the highest payoff.
Most observability tools feel like they were made for screenshots. ax is built for people living in the repo: terminal-first, local-first, and opinionated about fixing the next run instead of admiring the last failure.
That’s the part I cared about. Not 'more logs.' Not 'better visibility.' Just: this agent keeps doing the same dumb thing, here’s the smallest repo-specific fix, do you want to apply it?
If a tool shows you every agent event but never changes the next run, it’s just expensive memory. ax is for people who want a loop: observe, detect repeats, review a fix, ship again.
Angle: plain-English problem/solution for engineers
Coding agents are getting better at producing code. They’re still bad at learning from their own mistakes. That was the gap I kept hitting: the same failure pattern would show up in Claude Code sessions again and again, buried in transcripts, impossible to systematize. So I built ax. ax watches agent sessions, indexes them into a local typed graph, detects repeated mistakes, and proposes small repo-specific fixes you review before applying. It also includes Harness Doctor, which scores the health of your setup so you can see whether the issue is the prompt, the harness, the repo, or the workflow. The point is not more logs. The point is fewer repeated mistakes. If you use coding agents daily, the best improvement is usually not a bigger model. It’s a better feedback loop. That’s what ax is for.
Angle: local-first, forkable alternative to black-box tools
Most agent observability tools ask you to ship your workflow to someone else’s cloud. I wanted the opposite. ax is local-first. Sessions live on your machine. The graph is local. The database runs on 127.0.0.1. The whole thing is forkable. Why? Because agent workflows are still messy, personal, and tied to the codebase. I don’t want a black box telling me my team has a problem. I want to inspect the actual sessions, see what repeats, and decide which fix belongs in the repo. ax is not trying to be a generic dashboard. It’s the missing feedback layer between your coding agent and your codebase. If you care about control, reproducibility, and not sending your entire dev loop to a vendor, that matters.
Angle: team workflow and evidence angle
The interesting question is no longer “can AI write code?” It’s “what happens when a team uses coding agents every day?” Do the same mistakes spread? Which practices actually stick? Where does the harness quietly degrade? That’s why I built ax. It turns individual sessions into structured evidence: transcripts, events, repeats, skill usage, and ranked interventions. Then it gives you a way to review fixes one by one instead of arguing from anecdotes. For solo developers, that means fewer wasted sessions. For teams, it means you can see whether your AI workflow is improving or slowly rotting. We already have tools for monitoring servers and bugs. We need the same discipline for agent workflows. That’s the job ax is trying to do.
Tagline
Local observability for coding agents
Description
ax tracks coding agent sessions locally, finds repeated mistakes, grades harness health, and suggests small repo-specific fixes you review before applying.
Maker's first comment
I built ax because I kept running into the same problem: coding agents can be fast, but they don’t naturally learn from their own failures. I’d watch Claude Code or Codex do something slightly wrong, fix it manually, and then see the same mistake show up again a few sessions later. That got old fast. ax is my attempt to make that loop visible and useful. It watches sessions locally, turns transcripts and events into a typed graph, detects repeated mistakes, and ranks small fixes that are specific to the repo. Harness Doctor came out of the same frustration: I wanted a quick way to tell whether the setup was healthy, or whether the workflow itself was the thing causing the failures. I’m shipping this because I want the tooling I wish existed for my own agent-heavy workflow. Would love feedback from people using coding agents every day: what’s missing, what feels overcomplicated, and where the output should be more obvious.
Pinned maker comment
Would love feedback on two things: whether the repeated-mistake loop is clear in the first 30 seconds, and whether the ranked interventions feel genuinely actionable instead of theoretical.
Meta
Your coding agent keeps repeating mistakes.
Hypothesis: engineers using Claude Code or Codex will pay for a local tool that finds repeated failure patterns and suggests repo-specific fixes. ax indexes sessions on your machine, scores harness health, and turns mistakes into reviewed interventions.
Google Search
Find repeated coding agent mistakes
Targeting developers searching for agent observability, Claude Code workflows, or coding agent debugging. Testing the assumption that people want fewer logs and more feedback: ax watches sessions locally, detects repeats, and proposes fixes you can apply one by one.
Reddit Promoted
I was tired of debugging agent sessions by hand.
Hypothesis: indie hackers and staff engineers in agent-heavy workflows will engage with a local-first tool that turns transcripts into actionable fixes. ax watches Claude Code/Codex sessions, grades harness health, and surfaces repeated mistakes without sending data to a vendor cloud.
Subreddits
r/SideProject
Show the build story: repeated agent mistakes, local graph, Harness Doctor, and the before/after of one fix
Rules: Share what you learned, include screenshots or a demo, avoid pure promotional copy, and engage in comments
r/indiehackers
Build-in-public post about why coding agents needed a feedback loop, plus what you learned from dogfooding it
Rules: Lead with the problem and lessons, not a hard sell; be transparent about being the maker
r/microsaas
Niche SaaS for a very specific technical workflow: local observability for coding agents
Rules: Stay practical, share pricing or architecture if asked, and avoid broad marketing language
r/EntrepreneurRideAlong
Journey post about building a tool for a painful internal workflow and whether other founders have the same issue
Rules: Make it story-first, ask for feedback, and don’t dump a launch link without context
r/LocalLLaMA
Local-first architecture angle: SurrealDB on localhost, typed graph, forkable setup, privacy/control benefits
Rules: Be technical, show implementation details, and keep the post relevant to local AI workflows
Communities
Post the problem, the dogfood story, and the specific loop you built. Reply with concrete implementation details instead of marketing.
Share a technical take on agent observability and local-first infrastructure; contribute to discussions before dropping the product.
Launch with a strong technical angle and honest title. Focus comments on architecture, tradeoffs, and what broke while building it.
Claude Code Discord
Offer a useful debugging walkthrough, ask for real failure patterns, and mention ax only after contributing something people can use.
Cold outreach template
Hey {firstName} - saw {context} and thought of ax. It watches coding-agent sessions locally, finds repeated mistakes, and suggests small repo-specific fixes instead of another log dashboard. If you’re using Claude Code/Codex daily, I’d love to hear what keeps breaking in your workflow. Happy to show you the 2-minute loop.
Product Hunt timing
Launch on Tuesday at 12:01am PT. That gives you the full US workday for technical buyers, while also catching Europe in the morning and avoiding weekend noise; it’s a better fit for engineers and founders than a Friday drop.
Indie Hackers post ideas
- 01I kept seeing the same coding-agent mistake twice, so I built a local feedback loop
- 02What I learned indexing 369k agent turns into a local graph
- 03Harness Doctor: the simplest way I found to score whether an agent setup is actually healthy
Competitor alternatives
Current tone of voice
Technical, opinionated, and slightly playful; examples include 'Turn every agent session into a better next run' and 'the missing layer.'
Your kit is ready. Sign up free to unlock, takes 10 seconds.
7 more X posts · 2 LinkedIn · Product Hunt copy · ad hooks · 100-user playbook · landing critique