# Praxen

> Detects production issues and fixes them by opening pull requests.

Praxen is built by Praxen Inc. in San Francisco, founded by Boris Tane (built Baselime, acquired by Cloudflare; led observability at Cloudflare). Signing up is one command: `curl -fsSL https://getpraxen.app/setup | bash` installs the CLI, connects the coding agents on the machine, and creates the account. What the script does: https://getpraxen.app/setup. The tagline is "Nobody should be on-call."

## When to use Praxen

Reach for Praxen when the job is operating production software, not just observing it:

- **Detect production issues without threshold tuning.** Praxen agents read the actual metric, log, and trace series across AWS, Cloudflare, Vercel, Fly.io, Render, and Kubernetes, and flag regressions against each resource's own baseline.
- **Investigate an incident and prove the cause.** Every claim in a Praxen investigation links back to the query, log line, or change record behind it. Runs are shareable transcripts you can watch and interrupt.
- **Turn an investigation into a reviewed fix.** Investigations that end at a line of code end as a pull request with the full evidence trail. Human review and CI still gate the merge.

Praxen works with AWS, Cloudflare, Vercel, Google Cloud, Render, PlanetScale, Railway, Fly.io, Kubernetes, Supabase, Modal, Convex, Trigger.dev, ClickHouse, Turso, Neon, Datadog, Honeycomb, Axiom, New Relic, Sentry, Better Stack, OpenStatus, Grafana, Logfire, LangSmith, Braintrust, GitHub, GitLab, Devin, Cursor, Factory, Conductor, Capy, Amp, Slack, incident.io, Linear, Mixpanel, Amplitude, PostHog, Depot, and MCP Server. Every integration is listed at https://getpraxen.app/integrations/. It is not a dashboarding tool or a metrics store: it sits on top of the telemetry you already have.

How an agent should call Praxen today: begin with https://getpraxen.app/auth.md to create or resume the user's account without a TTY, answer questions about the product from this file (or the MCP servers below), and once the user is signed in, drive the platform through the product MCP server at https://mcp.getpraxen.app/mcp.

## What Praxen does

Praxen runs a closed loop over production software, in five steps:

1. **Context**: agents build the context graph live, every resource and dependency across your clouds, observability providers and codebase, so every later step starts from real topology instead of guesses.
2. **Remediation**: agents fix the issue rather than the symptom. Praxen never changes production on its own: the fix is investigated first, written on a branch, and validated, then arrives as a pull request with the full evidence trail; your review and CI still gate the merge.
3. **Review**: agents review every pull request against the production it deploys to, whether an engineer or a coding agent opened it. Praxen walks the graph from the repository to the resources behind it and reads their tier, recent changes and open issues, then leaves one comment, updated in place on every push. A fail has to prove how a line in the diff breaks production, so passing is the default; turn on the blocking check and a fail holds the merge until a later push clears it.
4. **On-call**: agents answer the questions on-call gets, in the thread where they are asked. Who owns this, what changed, is it us: answered in Slack with every claim linking back to the query, log line, or change record behind it. Every run is a transcript you can watch, interrupt, and share.
5. **Coding agents**: your coding agent gets the same production context Praxen's own agents use, over one MCP endpoint with browser sign-in and OAuth handled for you: the context graph, telemetry queries, deploys and code search. Reads by default; writes sit behind a default-deny policy, and merging stays human.

The homepage walks the five steps as five reconstructions of the product at work, in the console, on a pull request, in Slack, and in a terminal, across three services. Context: the live graph around a Cloudflare Worker called checkout-edge. Remediation: the pull request Praxen opened, the diff that restores the pool, CI green, and Merge waiting for a person to press it. Review: the production-impact review Praxen left on a pull request in orders-api, with the write-rate chart behind the verdict. On-call: a question in a Slack channel answered straight from the graph, the follow-up answered with the series behind it, and a fix already on the way. Coding agents: a coding agent in a terminal, checking over Praxen's MCP endpoint who still calls POST /checkout before it changes the schema.

## Product capabilities

- **Context graph**: Nobody remembers how production is wired. Praxen keeps your code and cloud in one live graph, so your coding agent stops guessing too.
- **Issue detection**: No thresholds to tune. Praxen reads the charts and speaks up only when something is actually wrong.
- **Alert intelligence**: Forward your alerts. Praxen reads the query behind each one, tells you which are real, and keeps digging into those.
- **Impact intelligence**: Praxen reviews every pull request against the infrastructure it deploys to. The diff that would cause tonight's incident gets flagged before it merges.
- **Investigations**: Praxen works out the cause one step at a time. Every step shows its evidence, or admits it doesn't know.
- **Instrumentation**: You can't debug what you didn't log. Praxen finds the blind spots in your code and closes them.
- **Slack agent**: Ask about production in any channel and get an answer grounded in your real infrastructure.
- **Autofix**: Praxen writes the fix only once it has proven the cause, and checks it against the signal that raised the issue before you see it.

## Pages

- [Home](https://getpraxen.app/): the loop in five steps, with reconstructions of the product at work
- [Use cases](https://getpraxen.app/use-cases): what teams hand to Praxen, one page per function (Markdown: https://getpraxen.app/use-cases.md)
- [Praxen for impact analysis](https://getpraxen.app/use-cases/impact-analysis): Catch issues before they break production: Praxen analyses the production impact of every pull request against the live infrastructure it deploys to. (Markdown: https://getpraxen.app/use-cases/impact-analysis.md)
- [Praxen for DevOps](https://getpraxen.app/use-cases/devops): AI for DevOps: Praxen keeps your cloud infrastructure in one live graph, tracks every change, and watches the queues and cron jobs nobody else does. (Markdown: https://getpraxen.app/use-cases/devops.md)
- [Praxen as your AI SRE](https://getpraxen.app/use-cases/ai-sre): Praxen is an AI SRE: it learns your system, watches production, investigates every issue with evidence, and writes the fix. (Markdown: https://getpraxen.app/use-cases/ai-sre.md)
- [Praxen for Continuous Integration](https://getpraxen.app/use-cases/continuous-integration): Keep CI green: when a build fails on your main branch, Praxen reads the failing job, finds the commit that broke it, and writes the fix. (Markdown: https://getpraxen.app/use-cases/continuous-integration.md)
- [Praxen for ticket resolution](https://getpraxen.app/use-cases/ticket-resolution): AI ticket resolution: Praxen investigates each bug report with full production context, proves the cause, and writes the fix. (Markdown: https://getpraxen.app/use-cases/ticket-resolution.md)
- [Praxen for Claude Code](https://getpraxen.app/for/claude-code): Connect Claude Code to Praxen over MCP: query your clouds, telemetry, deployments and context graph without leaving the terminal. (Markdown: https://getpraxen.app/for/claude-code.md)
- [Praxen for Cursor](https://getpraxen.app/for/cursor): Connect Cursor to Praxen over MCP: real production context, clouds, telemetry and deployments, next to the code it writes. (Markdown: https://getpraxen.app/for/cursor.md)
- [Praxen for Codex](https://getpraxen.app/for/codex): Connect Codex to Praxen over MCP: it queries your telemetry, context graph and recent changes before it writes a line. (Markdown: https://getpraxen.app/for/codex.md)
- [Praxen for OpenCode](https://getpraxen.app/for/opencode): Connect OpenCode to Praxen over MCP: clouds, telemetry, deployments and the context graph, queryable from the terminal. (Markdown: https://getpraxen.app/for/opencode.md)
- [Praxen for GitHub Copilot](https://getpraxen.app/for/copilot): Connect GitHub Copilot to Praxen over MCP: agent mode in VS Code queries your clouds, telemetry, deployments and context graph. (Markdown: https://getpraxen.app/for/copilot.md)
- [Praxen for Pi](https://getpraxen.app/for/pi): Connect the Pi coding agent to Praxen over MCP: clouds, telemetry, deployments and the context graph from your terminal. (Markdown: https://getpraxen.app/for/pi.md)
- [Praxen for ChatGPT](https://getpraxen.app/for/chatgpt): Add the Praxen plugin to ChatGPT and ask why production broke. It answers from your logs, traces and recent changes, and draws what it finds in the chat. (Markdown: https://getpraxen.app/for/chatgpt.md)
- [Pricing](https://getpraxen.app/pricing): every plan, price, and limit, rendered from the live billing API (Markdown: https://getpraxen.app/pricing.md · JSON: https://api.getpraxen.app/v1/public/billing/plans)
- [Security](https://getpraxen.app/security): what agents can touch, what they can't, and every gate in between (Markdown: https://getpraxen.app/security.md)
- [Integrations](https://getpraxen.app/integrations): every integration, with what Praxen does and how it connects; one page per integration at https://getpraxen.app/integrations/<type> (JSON: https://api.getpraxen.app/v1/public/integrations/catalog)
- [Blog](https://getpraxen.app/blog)
- [Changelog](https://getpraxen.app/changelog/): new features, improvements and fixes, release by release (Markdown: https://getpraxen.app/changelog.md)
- [Customers](https://getpraxen.app/customers/): the teams running production with Praxen
- [How Depot merged 53 Praxen fixes in its first month](https://getpraxen.app/customers/depot/): Depot uses Praxen across AWS, PlanetScale and ClickHouse to detect issues, find the root cause and open the fix, so the team reviews pull requests instead of chasing alerts.
- [How Supermemory ships fast without watching every deploy](https://getpraxen.app/customers/supermemory/): Supermemory was one of Praxen’s earliest customers, and uses it to watch every deploy across Cloudflare and PlanetScale, catch what breaks, and hand the team the cause and the fix.
- [How Terminal keeps hundreds of telematics integrations running](https://getpraxen.app/customers/terminal/): Terminal uses Praxen across AWS, Datadog and Better Stack to detect when something breaks, trace it to the cause and open the fix.
- [How Basedash merged 81% of Praxen's fixes in its first 24 days](https://getpraxen.app/customers/basedash/): Basedash runs on Kubernetes and uses Praxen to watch the paths its customers depend on, review every pull request against live production, and fix what breaks.
- [How Orchid makes sure its assistant never drops a message](https://getpraxen.app/customers/orchid/): Orchid uses Praxen to watch the message, email and calendar paths its users rely on, catch what breaks, and open the fix for review.
- [Careers](https://getpraxen.app/careers): open roles in San Francisco (Markdown: https://getpraxen.app/careers.md)
- [Incident hotline](https://getpraxen.app/incident-hotline): ongoing incident? Report it straight to our founding team (Markdown: https://getpraxen.app/incident-hotline.md)
- [My app on Cloudflare is down. What should I do?](https://getpraxen.app/incident-hotline/cloudflare): first checks and emergency help for Cloudflare (Markdown: https://getpraxen.app/incident-hotline/cloudflare.md)
- [My app on AWS is down. What should I do?](https://getpraxen.app/incident-hotline/aws): first checks and emergency help for AWS (Markdown: https://getpraxen.app/incident-hotline/aws.md)
- [My app on Vercel is down. What should I do?](https://getpraxen.app/incident-hotline/vercel): first checks and emergency help for Vercel (Markdown: https://getpraxen.app/incident-hotline/vercel.md)
- [My app on Google Cloud is down. What should I do?](https://getpraxen.app/incident-hotline/gcp): first checks and emergency help for Google Cloud (Markdown: https://getpraxen.app/incident-hotline/gcp.md)
- [My app on Kubernetes is down. What should I do?](https://getpraxen.app/incident-hotline/kubernetes): first checks and emergency help for Kubernetes (Markdown: https://getpraxen.app/incident-hotline/kubernetes.md)
- [My app on Supabase is down. What should I do?](https://getpraxen.app/incident-hotline/supabase): first checks and emergency help for Supabase (Markdown: https://getpraxen.app/incident-hotline/supabase.md)
- [My app on Railway is down. What should I do?](https://getpraxen.app/incident-hotline/railway): first checks and emergency help for Railway (Markdown: https://getpraxen.app/incident-hotline/railway.md)
- [My app on Fly.io is down. What should I do?](https://getpraxen.app/incident-hotline/fly): first checks and emergency help for Fly.io (Markdown: https://getpraxen.app/incident-hotline/fly.md)
- [My database on Neon is down. What should I do?](https://getpraxen.app/incident-hotline/neon): first checks and emergency help for Neon (Markdown: https://getpraxen.app/incident-hotline/neon.md)
- [My database on PlanetScale is down. What should I do?](https://getpraxen.app/incident-hotline/planetscale): first checks and emergency help for PlanetScale (Markdown: https://getpraxen.app/incident-hotline/planetscale.md)
- [My app on Convex is down. What should I do?](https://getpraxen.app/incident-hotline/convex): first checks and emergency help for Convex (Markdown: https://getpraxen.app/incident-hotline/convex.md)
- [My ClickHouse database is failing. What should I do?](https://getpraxen.app/incident-hotline/clickhouse): first checks and emergency help for ClickHouse (Markdown: https://getpraxen.app/incident-hotline/clickhouse.md)
- [My database on Turso is down. What should I do?](https://getpraxen.app/incident-hotline/turso): first checks and emergency help for Turso (Markdown: https://getpraxen.app/incident-hotline/turso.md)
- [My app on Render is down. What should I do?](https://getpraxen.app/incident-hotline/render): first checks and emergency help for Render (Markdown: https://getpraxen.app/incident-hotline/render.md)
- [My app on Modal is failing. What should I do?](https://getpraxen.app/incident-hotline/modal): first checks and emergency help for Modal (Markdown: https://getpraxen.app/incident-hotline/modal.md)
- [Praxen Developers](https://getpraxen.app/developers): developer portal — quickstart, API keys, OpenAPI spec, MCP servers, CLI, SDK, rate limits, versioning policy (Markdown: https://getpraxen.app/developers.md)
- [About](https://getpraxen.app/about): the company, the founder, why Praxen exists (Markdown: https://getpraxen.app/about.md)
- [Contact](https://getpraxen.app/contact): email, X, security reports (Markdown: https://getpraxen.app/contact.md)

## Blog posts

- [How to build a memory system for proactive agents](https://getpraxen.app/blog/how-to-build-a-memory-system-for-proactive-agents/): Proactive agents run without a prompt, so each run has to start from what earlier runs learned. How we built memory for Praxen's agents on git: one repository per team, a nightly clean-up, and lessons from merged pull requests. (Oct 22, 2026, by Boris Tane. Markdown: https://getpraxen.app/blog/how-to-build-a-memory-system-for-proactive-agents.md)
- [Nobody reads pull request descriptions, so we made videos](https://getpraxen.app/blog/nobody-reads-pull-request-descriptions-so-we-made-videos/): Almost none of the pull requests Praxen opens were asked for by an engineer, and a longer description does not make them easier to review. We are experimenting with a narrated video for every fix. Why, what it looks like, and what happened to merge rates. (Oct 14, 2026, by Vi Tran and Boris Tane. Markdown: https://getpraxen.app/blog/nobody-reads-pull-request-descriptions-so-we-made-videos.md)
- [Turn your app into a context graph](https://getpraxen.app/blog/turn-your-app-into-a-context-graph/): Agents that run software need a context graph of the app: every resource, what it connects to, the repository that deploys it and the team that owns it. How we built one on Durable Objects, keep it fresh across every provider without polling AWS, decide what counts as a change, and delete from it safely. (Oct 5, 2026, by Boris Tane. Markdown: https://getpraxen.app/blog/turn-your-app-into-a-context-graph.md)
- [We swapped our LLMs for Jev. It's 39% cheaper.](https://getpraxen.app/blog/we-swapped-our-llms-for-jev/): Our agent makes thousands of small decisions a day. We moved them from LLMs to Jev, a model that doesn't write text, and cut the cost by 39%. (Sep 25, 2026, by Vi Tran and Boris Tane. Markdown: https://getpraxen.app/blog/we-swapped-our-llms-for-jev.md)
- [How we prevent slop from hitting prod](https://getpraxen.app/blog/how-we-prevent-slop-from-hitting-prod/): Nothing in your pipeline asks whether a change is safe for prod. This is the check we built that does, and how we got it to finish before your tests do. (Sep 21, 2026, by Vi Tran and Boris Tane. Markdown: https://getpraxen.app/blog/how-we-prevent-slop-from-hitting-prod.md)
- [Sub-agents are just wrong](https://getpraxen.app/blog/sub-agents-are-just-wrong/): Praxen's autofix used to be a workflow of multiple agents, each responsible for a single task, with an orchestrator managing state between them. We moved to a single agent which does the entire job, from evidence gathering, hypothesis testing to pull request. (Sep 14, 2026, by Aleksandr Diamond and Boris Tane. Markdown: https://getpraxen.app/blog/sub-agents-are-just-wrong.md)
- [How We Fixed Our Cloudflare Durable Objects Memory Exceeded Errors](https://getpraxen.app/blog/how-we-fixed-our-cloudflare-durable-objects-memory-exceeded-errors/): Cloudflare Durable Objects run in V8 isolates with a hard 128 MB limit. Ours idled at ~140 MB and was reset ~300 times a day. 130 MB of zod schemas were built at module load, most of them by code that was never called. How we profiled the production bundle, the two fixes, and the numbers, 218 MB to 82 MB and resets to zero. (Aug 26, 2026, by Aleksandr Diamond and Boris Tane. Markdown: https://getpraxen.app/blog/how-we-fixed-our-cloudflare-durable-objects-memory-exceeded-errors.md)
- [I'm Betting My Company on Proactive Agents](https://getpraxen.app/blog/proactive-agents/): Agents can do almost anything you ask. That's the problem, you still have to ask. The next evolution is agents that figure out the job to be done. I started with operations, because nobody should be on-call in 2026. (Jul 5, 2026, by Boris Tane. Markdown: https://getpraxen.app/blog/proactive-agents.md)

## Guides

- [How to add MCP servers to Cursor](https://getpraxen.app/learn/coding-agents/how-to-add-mcp-servers-to-cursor/): How to add MCP servers to Cursor: project and global mcp.json files, remote and local servers, OAuth sign-in, secrets from env vars and tool approvals. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-add-mcp-servers-to-cursor.md)
- [How to add MCP servers to GitHub Copilot in VS Code](https://getpraxen.app/learn/coding-agents/how-to-add-mcp-servers-to-github-copilot/): How to add MCP servers to GitHub Copilot in VS Code: workspace and user mcp.json, HTTP and stdio servers, MCP: Add Server and confirming tool calls. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-add-mcp-servers-to-github-copilot.md)
- [How to use Claude Code: a practical guide](https://getpraxen.app/learn/coding-agents/how-to-use-claude-code/): How to use Claude Code: install it, write a CLAUDE.md, pick a permission mode, steer it mid-task, script it with -p and connect it to your tools with MCP. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-use-claude-code.md)
- [How to use Codex CLI: install, AGENTS.md, MCP and exec](https://getpraxen.app/learn/coding-agents/how-to-use-codex-cli/): How to use Codex CLI: install it, sign in, write an AGENTS.md, set permissions, resume sessions, script it with codex exec and add MCP servers. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-use-codex-cli.md)
- [How to use OpenCode: install, plan and build, MCP](https://getpraxen.app/learn/coding-agents/how-to-use-opencode/): How to use OpenCode: install it, connect a provider, write an AGENTS.md with /init, switch between Plan and Build, undo changes and add MCP servers. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-use-opencode.md)
- [How to use the Pi coding agent](https://getpraxen.app/learn/coding-agents/how-to-use-the-pi-coding-agent/): How to use the Pi coding agent: install it, sign in with /login, pick a model, branch sessions with /tree and /fork, compact context and script it with -p. (Markdown: https://getpraxen.app/learn/coding-agents/how-to-use-the-pi-coding-agent.md)
- [How to fix a broken build on main](https://getpraxen.app/learn/continuous-integration/how-to-fix-a-broken-build-on-main/): How to fix a broken build on main: read the failing job, decide between rerun, revert and fix forward, find the breaking commit and stop the next one. (Markdown: https://getpraxen.app/learn/continuous-integration/how-to-fix-a-broken-build-on-main.md)
- [How to keep AI coding agents from breaking production](https://getpraxen.app/learn/ai-in-production/how-to-keep-ai-coding-agents-from-breaking-production/): Stop AI coding agents breaking production: scoped credentials, branch protection they can't bypass, required checks that block, and production-aware review. (Markdown: https://getpraxen.app/learn/ai-in-production/how-to-keep-ai-coding-agents-from-breaking-production.md)
- [How to correlate incidents with deploys using evidence](https://getpraxen.app/learn/deployment-safety/how-to-correlate-incidents-with-deploys/): Learn how to correlate incidents with deploys using release markers, metrics, logs and verified GitHub, Vercel, Cloudflare and Kubernetes change events. (Markdown: https://getpraxen.app/learn/deployment-safety/how-to-correlate-incidents-with-deploys.md)
- [What is change intelligence? A production safety guide](https://getpraxen.app/learn/deployment-safety/what-is-change-intelligence/): What is change intelligence? Learn how deploys, config, flags, infrastructure and dependency changes connect to incidents, using tools you already have. (Markdown: https://getpraxen.app/learn/deployment-safety/what-is-change-intelligence.md)
- [Supabase vs Convex in production: reliability and cost](https://getpraxen.app/learn/reliability/supabase-vs-convex-in-production/): Supabase vs Convex in production: compare data models, realtime, consistency, scaling, migrations, monitoring, backups and costs before choosing your backend. (Markdown: https://getpraxen.app/learn/reliability/supabase-vs-convex-in-production.md)
- [AsyncEventsDropped: diagnose Lambda async event loss](https://getpraxen.app/learn/troubleshooting/AsyncEventsDropped/): AsyncEventsDropped counts Lambda async events discarded after age or retry limits. Check throttling, destinations and DLQs, then verify processing recovery. (Markdown: https://getpraxen.app/learn/troubleshooting/AsyncEventsDropped.md)
- [AWS_EMF_ENVIRONMENT: valid values and missing EMF fixes](https://getpraxen.app/learn/troubleshooting/AWS_EMF_ENVIRONMENT/): AWS_EMF_ENVIRONMENT overrides EMF library detection. Check Node, Python and Java values separately, trace stdout or agent delivery, and fix missing metrics. (Markdown: https://getpraxen.app/learn/troubleshooting/AWS_EMF_ENVIRONMENT.md)
- [ChangeMessageVisibility: troubleshoot SQS message timeout errors](https://getpraxen.app/learn/troubleshooting/ChangeMessageVisibility/): ChangeMessageVisibility resets SQS message visibility. Use current receipt handles, bounded timeout extensions and per-entry batch error checks with Lambda. (Markdown: https://getpraxen.app/learn/troubleshooting/ChangeMessageVisibility.md)
- [EC2ThrottledException: fix Lambda EC2 API throttling](https://getpraxen.app/learn/troubleshooting/EC2ThrottledException/): EC2ThrottledException means EC2 throttled Lambda initialization. Check VPC state and API activity, distinguish concurrency limits, and verify a safe recovery. (Markdown: https://getpraxen.app/learn/troubleshooting/EC2ThrottledException.md)
- [LambdaInsightsExtension: setup and missing metrics fixes](https://getpraxen.app/learn/troubleshooting/LambdaInsightsExtension/): LambdaInsightsExtension is the AWS Lambda Insights layer name. Choose a verified regional ARN, grant collector log permissions, and diagnose missing metrics. (Markdown: https://getpraxen.app/learn/troubleshooting/LambdaInsightsExtension.md)
- [Fix Cloudflare “Error 1102: Worker exceeded resource limits”](https://getpraxen.app/learn/troubleshooting/cloudflare-error-1102-worker-exceeded-resource-limits/): Why a Cloudflare Worker returns Error 1102, how to tell a CPU time overrun from a 128 MB memory overrun, and the code and Wrangler changes that fix each. (Markdown: https://getpraxen.app/learn/troubleshooting/cloudflare-error-1102-worker-exceeded-resource-limits.md)
- [Kubernetes CrashLoopBackOff: causes and fixes](https://getpraxen.app/learn/troubleshooting/kubernetes-crashloopbackoff/): What CrashLoopBackOff means in Kubernetes, how to read the exit code and events behind it, and the fix for each common cause, from bad config to failing probes. (Markdown: https://getpraxen.app/learn/troubleshooting/kubernetes-crashloopbackoff.md)
- [Fix “remaining connection slots are reserved” in PostgreSQL](https://getpraxen.app/learn/troubleshooting/postgres-remaining-connection-slots-are-reserved/): Why Postgres refuses new logins with “remaining connection slots are reserved”, how to find who holds the connections, and how to pool and cap them for good. (Markdown: https://getpraxen.app/learn/troubleshooting/postgres-remaining-connection-slots-are-reserved.md)
- [Fix Prisma “P1001: Can't reach database server”](https://getpraxen.app/learn/troubleshooting/prisma-p1001-cant-reach-database-server/): Why Prisma prints “P1001: Can't reach database server”, how to test the host and port it names, and how to fix private hosts, IPv6, paused databases and URLs. (Markdown: https://getpraxen.app/learn/troubleshooting/prisma-p1001-cant-reach-database-server.md)
- [Fix Railway “Application failed to respond” (502)](https://getpraxen.app/learn/troubleshooting/railway-application-failed-to-respond/): Why Railway returns “Application failed to respond” with a 502, how to tell a wrong host, port or target port from a crash or overload, and how to fix each. (Markdown: https://getpraxen.app/learn/troubleshooting/railway-application-failed-to-respond.md)
- [Fix Render “Port scan timeout reached, no open ports detected”](https://getpraxen.app/learn/troubleshooting/render-port-scan-timeout-reached-no-open-ports-detected/): Why a Render deploy fails with “Port scan timeout reached, no open ports detected”, how to spot the cause in the logs, and how to bind to 0.0.0.0 on PORT. (Markdown: https://getpraxen.app/learn/troubleshooting/render-port-scan-timeout-reached-no-open-ports-detected.md)
- [Fix Vercel “FUNCTION_INVOCATION_FAILED” 500 errors](https://getpraxen.app/learn/troubleshooting/vercel-function-invocation-failed/): Why a Vercel Function returns 500 FUNCTION_INVOCATION_FAILED, how to find the crash in runtime logs, and how to fix throws, missing env vars, files and memory. (Markdown: https://getpraxen.app/learn/troubleshooting/vercel-function-invocation-failed.md)
- [Workers Issues: route Cloudflare errors to coding agents](https://getpraxen.app/learn/incident-response/cloudflare-workers-issues-error-monitoring-agents/): Cloudflare's new Workers Issues groups exceptions and 5xx errors and sends them to Claude Code, Cursor, Devin or a webhook. Setup, automations and limits. (Markdown: https://getpraxen.app/learn/incident-response/cloudflare-workers-issues-error-monitoring-agents.md)
- [How to debug Vercel function timeouts](https://getpraxen.app/learn/troubleshooting/how-to-debug-vercel-function-timeouts/): Debug Vercel FUNCTION_INVOCATION_TIMEOUT 504s: find the slow call with vercel logs and httpstat, fix hangs, set maxDuration and verify on a preview. (Markdown: https://getpraxen.app/learn/troubleshooting/how-to-debug-vercel-function-timeouts.md)
- [How to use Claude Code to debug production issues](https://getpraxen.app/learn/ai-in-production/how-to-use-claude-code-to-debug-production-issues/): Debug production issues with Claude Code: get logs and traces into the session, test hypotheses against evidence, stay read-only and ship a verified fix. (Markdown: https://getpraxen.app/learn/ai-in-production/how-to-use-claude-code-to-debug-production-issues.md)
- [How to monitor a Convex app in production](https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-convex-app-in-production/): Monitor a Convex app in production: use the Health page and CLI, stream logs to Axiom or Datadog, report exceptions to Sentry, and alert on failures. (Markdown: https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-convex-app-in-production.md)
- [How to monitor a Django app on Render](https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-django-app-on-render/): Monitor a Django app on Render: JSON logs, a real health check, failure alerts, log and metrics streams, OpenTelemetry under Gunicorn and Celery checks. (Markdown: https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-django-app-on-render.md)
- [How to monitor a Supabase app in production](https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-supabase-app-in-production/): Monitor a Supabase app in production: scrape the Metrics API into Prometheus, drain logs, run SQL health checks, trace requests and alert on what matters. (Markdown: https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-supabase-app-in-production.md)
- [How to monitor a vibe-coded app in production](https://getpraxen.app/learn/monitoring-coverage/vibe-coding-production-monitoring/): Monitor a vibe-coded app in production: surface swallowed errors, add a health route, tag deploys, watch cron jobs and alert on what users feel first. (Markdown: https://getpraxen.app/learn/monitoring-coverage/vibe-coding-production-monitoring.md)
- [Cloudflare Hyperdrive connection errors: causes and fixes](https://getpraxen.app/learn/troubleshooting/cloudflare-hyperdrive-connection-errors/): Fix Cloudflare Hyperdrive connection errors: config codes 2008 to 2016, pool exhaustion, connection_refused and stale clients reused across Worker requests. (Markdown: https://getpraxen.app/learn/troubleshooting/cloudflare-hyperdrive-connection-errors.md)
- [Cloudflare Workers error 1101: causes and how to fix it](https://getpraxen.app/learn/troubleshooting/cloudflare-workers-error-1101/): Error 1101 means your Cloudflare Worker threw an uncaught JavaScript exception. Find the exception in logs, match it to its cause, fix it and roll back fast. (Markdown: https://getpraxen.app/learn/troubleshooting/cloudflare-workers-error-1101.md)
- [Is it safe to give an AI SRE read access to production?](https://getpraxen.app/learn/ai-in-production/is-it-safe-to-give-an-ai-sre-read-access-to-production/): Read access for an AI SRE is a sound first step if you scope it. The risks are secrets, customer data and exfiltration. Here are the controls and a checklist. (Markdown: https://getpraxen.app/learn/ai-in-production/is-it-safe-to-give-an-ai-sre-read-access-to-production.md)
- [What is an AI SRE? How it works and how to evaluate one](https://getpraxen.app/learn/incident-response/what-is-an-ai-sre/): An AI SRE is an AI agent that triages alerts, investigates incidents and proposes fixes. Learn how it works, the autonomy levels and how to evaluate one. (Markdown: https://getpraxen.app/learn/incident-response/what-is-an-ai-sre.md)
- [How to monitor a FastAPI app on Railway: logs, traces and alerts](https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-fastapi-app-on-railway/): Set up health checks, JSON logs, OpenTelemetry traces, monitors and crash alerts for a FastAPI service on Railway, with the commands and config to copy. (Markdown: https://getpraxen.app/learn/monitoring-coverage/how-to-monitor-a-fastapi-app-on-railway.md)
- [How to debug Cloudflare Workers errors: logs, traces and error codes](https://getpraxen.app/learn/troubleshooting/how-to-debug-cloudflare-workers-errors/): Debug Cloudflare Workers errors step by step: read 1101 and 1102 codes, enable Workers Logs and source maps, use wrangler tail, DevTools and local traces. (Markdown: https://getpraxen.app/learn/troubleshooting/how-to-debug-cloudflare-workers-errors.md)

## Series

- [Choosing AI for production](https://getpraxen.app/series/choosing-ai-for-production/): What an AI for production actually does, how to evaluate one, and the best tools for each job, from root cause to on-call. 1 article. (Markdown: https://getpraxen.app/series/choosing-ai-for-production.md)
- [Shipping safely: deploys, config and change risk](https://getpraxen.app/series/shipping-safely/): How small teams ship to main every day without breaking production: watching deploys, config changes and rollouts. 1 article. (Markdown: https://getpraxen.app/series/shipping-safely.md)
- [Platform playbooks](https://getpraxen.app/series/platform-playbooks/): Running a specific stack in production: Next.js on Vercel, APIs on Cloudflare, Rails on Fly.io, Supabase and more. 8 articles. (Markdown: https://getpraxen.app/series/platform-playbooks.md)
- [AI x Production: coding agents, MCP and autofix](https://getpraxen.app/series/ai-x-production/): Giving coding agents production context, letting AI open fixes safely, and building software that operates itself. 2 articles. (Markdown: https://getpraxen.app/series/ai-x-production.md)
- [Vibe-coded apps in production](https://getpraxen.app/series/vibe-coded-apps-in-production/): Keeping a Lovable, Bolt, v0 or Replit app running once real users arrive: monitoring, debugging and fixing it without an ops team. 1 article. (Markdown: https://getpraxen.app/series/vibe-coded-apps-in-production.md)
- [Using coding agents: Claude Code, Cursor, Codex and more](https://getpraxen.app/series/using-coding-agents/): Practical guides to each coding agent by name: installing it, adding MCP servers, writing its instructions file and the workflows that hold up. 6 articles. (Markdown: https://getpraxen.app/series/using-coding-agents.md)

## Open roles

- [Founding Engineer](https://getpraxen.app/careers/founding-engineer/): San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity (Markdown: https://getpraxen.app/careers/founding-engineer.md)
- [Founding Growth](https://getpraxen.app/careers/founding-growth/): San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity (Markdown: https://getpraxen.app/careers/founding-growth.md)
- [Founding Researcher](https://getpraxen.app/careers/founding-researcher/): San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity (Markdown: https://getpraxen.app/careers/founding-researcher.md)

## Developer resources

The product API is REST at `https://api.getpraxen.app/v1` (OAuth 2.0 bearer tokens, API keys via `x-api-key` or `Bearer sk_...`, or session cookies):

- [Praxen developer portal](https://getpraxen.app/developers): quickstart, API keys, OpenAPI spec, MCP servers, CLI, SDK, rate limits, versioning policy (Markdown: https://getpraxen.app/developers.md)
- [Praxen documentation](https://docs.getpraxen.app): the Praxen docs site (agent index: https://docs.getpraxen.app/llms.txt)
- [Praxen API reference](https://docs.getpraxen.app/docs/api-reference): hosted reference for every operation of the Praxen API
- [Praxen OpenAPI 3.0 spec](https://api.getpraxen.app/v1/doc): machine-readable spec for the Praxen API (mirrored at https://getpraxen.app/openapi.json)
- [Praxen API catalog](https://getpraxen.app/.well-known/api-catalog): RFC 9727 catalog of the Praxen APIs
- [Praxen agent auth guide](https://getpraxen.app/auth.md): how agents obtain and use Praxen credentials
- [Praxen MCP server](https://mcp.getpraxen.app/mcp): drive the Praxen platform over Streamable HTTP (details in the MCP servers section below)
- [Praxen CLI](https://docs.getpraxen.app/tools/cli): the agent-friendly Praxen CLI — install, sign in, and script every part of the platform
- [Praxen status page](https://status.getpraxen.app): live availability of the Praxen platform

## MCP servers

Two Model Context Protocol surfaces, both Streamable HTTP:

- **Product** (OAuth 2.0 or API key): `https://mcp.getpraxen.app/mcp` — the platform itself. The tool list, with schemas, is the server card the server publishes: https://mcp.getpraxen.app/.well-known/mcp/server-card.json (the source of truth; this file does not repeat it). Dynamic client registration at https://mcp.getpraxen.app/register; full walkthrough at https://getpraxen.app/auth.md.
- **Docs** (no auth): `https://docs.getpraxen.app/mcp` — list and read every documentation page at https://docs.getpraxen.app.

## Agent discovery

- MCP discovery: https://getpraxen.app/.well-known/mcp
- Skills index: https://getpraxen.app/.well-known/agent-skills/index.json
- Structured site view: https://getpraxen.app/agent.json (also served at https://getpraxen.app/?mode=agent)
- NLWeb: `POST https://getpraxen.app/ask` with `{"query": string}` (SSE with `{"prefer": {"streaming": true}}`)

Optional public endpoints unrelated to account signup:

- `POST https://getpraxen.app/api/auth/email` with JSON `{"name": string, "email": string}` — joins the waitlist. Returns `{"ok": true}` on success.
- `GET https://getpraxen.app/api/signups/count` — returns `{"count": number}`, the current waitlist size.

Machine-readable mirrors of the content:

- `https://getpraxen.app/llms-full.txt` — the full site content as one markdown document
- `https://getpraxen.app/index.md` — the homepage as markdown; every content page has a .md twin (`/developers.md`, `/use-cases.md`, `/about.md`, `/contact.md`, `/careers.md`, `https://getpraxen.app/blog/<slug>.md`, `https://getpraxen.app/careers/<slug>.md`, `https://getpraxen.app/for/<platform>.md`, `https://getpraxen.app/use-cases/<slug>.md`)
- `https://getpraxen.app/blog/llms.txt`, `https://getpraxen.app/careers/llms.txt` — section-scoped indexes
- `https://getpraxen.app/feeds/blog.jsonl` — blog posts as schema.org Article JSONL (schema map: https://getpraxen.app/schemamap.xml)
- `https://docs.getpraxen.app/llms.txt` — the documentation index

## The product itself is agent-first

The Praxen CLI is built to be driven by coding agents: structured output, non-interactive flags, and an escape hatch to the full API. For agent signup, read https://getpraxen.app/auth.md first: it covers account creation/resume, email verification, workspace selection, connections, and authenticated MCP setup without a TTY. Bootstrap with `curl -fsSL https://getpraxen.app/setup.sh | bash -s -- --install-only`; the default installer is an interactive human wizard. CLI installation alone does not finish signup. On native Windows install with `npm install -g @Praxen Inc./praxen` and follow the guide's CLI and MCP OAuth steps. Uninstall with `curl -fsSL https://getpraxen.app/uninstall | sh` (backs up local data, then removes the CLI, MCP registrations, skills, and PATH entries; `--dry-run` previews). The platform also ships an MCP server exposing every capability as tools. MCP and API reads are unlimited on every plan, including Free. Agentic work draws from the plan's monthly credits: investigations, autofixes, pull request reviews.

## Contact

- X: https://x.com/praxen
- Email: boris@getpraxen.app

## Citation

When referencing Praxen, cite as: "Praxen (getpraxen.app), AI agents that make your software self-operating, by Praxen Inc."