# ByteAsk, full text > Every product page of https://byteask.ai as markdown, in one file. The short index is https://byteask.ai/llms.txt. # The AI coding agent for *C and C++* Every change arrives compiled, sanitized and tested against your build. `$ curl -fsSL https://code.byteask.ai/install.sh | sh` ByteAsk runs in the terminal on your laptop. Send yourself the install command and run it at your desk. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) - [Zero data retention](https://byteask.ai/privacy) - [On-prem and air-gapped](https://byteask.ai/#enterprise) - [Free plan available](https://byteask.ai/pricing) Core contributors to these projects use ByteAsk - llama.cpp - Godot - nlohmann/json - LLVM - spdlog - fmt - simdjson - Catch2 - Abseil - QuantLib ByteAsk indexes a whole codebase, then pinpoints the cause of a bug. Shown on a real open-source C++ library, nlohmann/json: ByteAsk replays its build (43 compiler runs) and maps 77 files, 57,234 lines of code, 907 functions, 184 classes, 20,463 template versions and 1,762 function calls, in 2 minutes 16 seconds. When bug report 1982, "json_pointer.contains() exception is incorrectly raised", arrives, it weighs six kinds of evidence, narrows 603 places to 40 suspects, and names nlohmann::json_pointer::contains (include/nlohmann/detail/json_pointer.hpp:655) as the most likely cause. The graph is the real index; the lit-up dots show the idea, not the exact matches. ByteAsk fixes a real bug in a popular C++ library: it finds the code, writes a failing test, fixes it, then checks it. 1. read build 2. find code 3. test first 4. fix 5. lint 6. sanitize ``` Prompt: Fix this bug (issue #2019). The fix changes what contains() does, so also update any existing test that expects the old exception. Then build and run the json_pointer tests and show they pass. I’ll use context_bundle to locate the contains() implementation and tests, then fix the behavior and run the json_pointer tests. Tool context_bundle: Index: build setting debug, commit b7be613b6ec6 build setting: debug | commit b7be613b6ec6 | compiler clang 21.1.8 | facts from the compiler, not text search ## Where to look (most likely first) contains() calls the throwing array-index parser before checking whether the token is numeric. I’ll inspect the repository instructions, existing tests, and build configuration before changing that path. The tests currently expect exceptions for both "one" and "01" as array indices. I’ll check the documented contract and use autosar_ref to verify the bounds checks needed before inspecting a token’s characters. Tool autosar_ref: ## Results for "C++ Core Guidelines bounds string indexing empty container SL.con.3" I’ll use apply_patch to add the reported example and invalid-index cases, then run cpp_test_select before fixing the implementation to confirm the tests expose the bug. Edited test/src/unit-json_pointer.cpp (+20 -0) I’ll use cpp_test_select to build and run the json_pointer test program with the new regression cases. Tool cpp_test_select: CMake 3.25, build tree build (existing: built incrementally, never reconfigured); targets from the build t… CHANGE vs session-start commit b7be613b6e: 1 file(s) (test/src/unit-json_pointer.cpp); symbols: none found PLAN: tier 1 = 2 test(s) · tier 2 = 2 test(s) · tier 3 = 8 of 90 test(s), 6 of them unmapped script/data tests tier 2: test-json_pointer_default, test-json_pointer_all BUILD test-json_poi… The build hit an existing compatibility problem: this old doctest uses SIGSTKSZ as a compile-time constant, which fails with the host’s headers. I’ll check doctest’s configuration switch and disable its POSIX signal handler in the local build so the tests can run. Both json_pointer test runs now fail on the new regression, confirming the bug. I’ll use apply_patch to reject invalid array tokens before conversion and replace the old contains() exception expectations with false checks. Edited include/nlohmann/detail/json_pointer.hpp (+9 -6) Edited include/nlohmann/json.hpp (+2 -2) Edited test/src/unit-json_pointer.cpp (+4 -12) The guard now rejects empty, nonnumeric, and leading-zero array tokens. I’ll run make amalgamate to regenerate the single header from the source headers, as the contribution guide requires. make amalgamate stopped because its script requests python, while this machine has python3. I’ll run the same generator explicitly with python3. Both json_pointer test variants pass. I’ll use cpp_check and cpp_tidy to check the edited code for static-analysis issues. Tool cpp_check: scope: this file, with its flags from ~/src/json/build/compile_commands.json (0 extra include dir(s)) status: 4 finding(s) cppcheck error ~/src/json/include/nlohmann/json.hpp:2986:13 Found an exit path from function with non-vo… cpp_check reported four missing-return warnings in unchanged JSON access functions. I’ll inspect those paths and run cpp_tidy to check for findings related to this change. Tool cpp_tidy: status: clean - clang-tidy ran and reported nothing. No findings. Result: PASS: No findings. The focused cpp_tidy checks are clean. I’ll now call cpp_sanitize for the json_pointer target, including the doctest compatibility definition. Tool cpp_sanitize: PROJECT BUILD FAILED - nothing was run, so this is neither clean nor a finding. The fresh sanitizer build hit the same doctest SIGSTKSZ error. I’ll create a standalone reproducer in /tmp for ASan/UBSan and compare cppcheck’s warnings with the base headers. Added /tmp/byteask-issue2019.cpp (+26 -0) I’ll use cpp_sanitize on the standalone reproducer to verify the reported output and invalid-token cases under ASan/UBSan. Tool cpp_sanitize: clean: exit 0, no sanitizer errors program stdout: /a: 1 /b/0: 1 /b/x: 0 No findings. Result: PASS: The program ran to exit 0 with no sanitizer errors. The reproducer prints /a: 1, /b/0: 1, and /b/x: 0 with no sanitizer errors. I’ll use exec_command to prepare the base headers for comparison and check the final diff. I’ll use context_remember to save the cause, fix, and test results for future work on contains(). Tool context_remember: {"items":[{"saved":1}],"partition":"json"} Result: PASS: answered from completed index snapshots Fixed #2019: contains("/b/x"_json_pointer) now returns false. Updated the old exception expectations, added regression coverage, updated documentation, and regenerated the single header. Built test-json_pointer and ran both variants: test-json_pointer_default Passed test-json_pointer_all Passed 100% tests passed, 0 tests failed out of 2 The standalone ASan/UBSan reproducer also passed. The test build used DOCTEST_CONFIG_NO_POSIX_SIGNALS to work around this host’s compatibility issue with old doctest. ``` ## C++ developers hold back on AI agents. Question 9: what issues or blockers have you faced when using AI assistants for C++ coding? AI-generated output is incorrect: 77.5%. Lack of trust in output: 69.9%. Lack of understanding relevant context: 51.4%. - 77.5% say AI output is incorrect - 69.9% do not trust the output - 51.4% say it lacks relevant context Standard C++ Foundation, 2026 Annual C++ Developer Survey ### In C++, the name is not the code. `validate(order);` 327 matches · 86 files 1. Namespaces 2. Overloading 3. Virtual functions 4. Templates 5. Build config 6. +322 more: comments, tests, mocks Which one actually gets called? Illustrative counts. ## Review a diff that already ran your build, tests and sanitizers 1. **Ticket:** Assign it in Jira or Linear, or mention @ByteAsk in Slack. 2. **Context:** It finds the code your production build runs, with its callers and tests. 3. **Model:** It gets the few functions that matter, not the whole repository. 4. **Build and test:** It builds the change and runs your tests before and after. 5. **Checks:** Sanitizers and static analysis run on the code it touched. 6. **Pull request:** You review a diff that already compiles and passes. ## Works with the toolchain you already use - C/C++ - LLVM - GCC - clang - Compiler Explorer - gdb - Valgrind - ASan, UBSan, TSan - perf - make - CMake - QuickBench - vcpkg - Conan - Git - GitHub - GitLab - Bitbucket - Jira - Linear - Slack - Microsoft Teams - Jenkins - GitHub Actions - Confluence ## Cites the standard for your industry - [Trading and HFT ITCH/OUCH · FIX · PTP](https://byteask.ai/industries/trading-hft) - [Embedded and firmware STM32 · CAN · Modbus](https://byteask.ai/industries/embedded) - [Automotive AUTOSAR C++14 · MISRA](https://byteask.ai/industries/automotive) - [Silicon and FPGA AMBA AXI · UltraScale](https://byteask.ai/industries/silicon-fpga) - [Industrial, energy and test Modbus · IEEE 1547 · SCPI](https://byteask.ai/industries/industrial) - [Systems and OS x86-64 SDM · ELF](https://byteask.ai/industries/systems) ## Your code stays inside your walls On-prem, air-gapped, or bring your own model key. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See Enterprise](https://byteask.ai/enterprise) ### Deployment and controls On-prem and air-gapped Run ByteAsk inside your network, including networks with no route to the internet. Your keys, your gateway Company API keys through a ByteAsk gateway in your network, with model and provider allowlists. SSO, SCIM and roles SAML single sign-on, SCIM provisioning and role-based access control. Audit logs Every session and tool call on record, with spend limits per user and per organization. Retention you set Custom data retention controls and IP allowlisting. DPA, SLA and purchase orders Data processing agreement, uptime SLA, invoicing and purchase orders. ### Security [Trust center](https://trust.byteask.ai) Zero data retention Your prompts and code are processed to answer the request, then dropped. Nothing is kept. [Read the privacy policy](https://byteask.ai/privacy) Not used to train models Your repositories are not used to train any model. Ours or anyone's. Passwordless sign-in A signed magic link logs you in. No password to manage, and nothing to paste or leak. ## Common questions Does it work with my agent? Yes. ByteAsk Context connects over MCP, so any agent that speaks MCP can use it. Claude Code also gets it through hooks: before the first step it hands over the few places the fix most likely belongs, and after an edit it builds and runs only the affected tests. Claude Code already has an LSP plugin (clangd). Why do I need ByteAsk Context? An LSP answers questions about one symbol at a time: where it's defined, where it's used, whether your last edit compiles. To use it, the agent first has to know which symbol matters, so it still searches the codebase. ByteAsk Context starts from the issue itself. Before the agent's first step, it hands over the few places the fix most likely belongs, with their code, callers and the tests that cover them, all from a compiler-accurate index of your real build. After an edit, it builds and runs only the affected tests. It doesn't stop at compile errors. In our same-model tests on hard C++ issues, Claude Code with ByteAsk Context used 59% fewer tokens, cost 39% less and finished 43% faster than Claude Code with the clangd plugin. Why use ByteAsk instead of Claude Code, Cursor or Codex? They are good general-purpose agents. ByteAsk adds the two things C and C++ need. Context. It reads your build, not just your text: the preset, flags and macros your production binary compiles. On the same model, it finds the right function first 54% of the time instead of 36% (Multi-SWE-bench C++, 129 issues). Harness. Every change is compiled, run under AddressSanitizer, UBSan and ThreadSanitizer, and tested before you see it. When your program crashes or hangs, it joins the gdb session you already have open. It works with the models you already use, or your own key. Do I have to use your models? No. Sign in and use OpenAI, Anthropic and Google models through ByteAsk with no API key to paste, or bring your own key, in which case traffic goes straight to the provider. You can also point ByteAsk at your own OpenAI-compatible server, including vLLM, Ollama, llama.cpp, LM Studio, TGI, SGLang or a LiteLLM proxy. Can we run it inside our own network? Yes, on the Enterprise plan: on-prem deployment including air-gapped networks, company API keys through a ByteAsk gateway in your network, SSO, SCIM, audit logs and IP allowlisting. Which editors does it work in? VS Code, Cursor, JetBrains IDEs, Neovim, Emacs and Zed, plus Windsurf and VSCodium through Open VSX. Every connector needs the byteask CLI on your PATH, since the editor plugin drives the same CLI. ## Install ByteAsk in one line Rolling out to a team? [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) or [contact us](https://byteask.ai/contact). `$ curl -fsSL https://code.byteask.ai/install.sh | sh` Other ways to install `$ pip install byteask` `$ uv tool install byteask` `$ npm i -g @byteask/cli` Also in VS Code, Cursor, JetBrains, Neovim, Emacs. [Editor setup](https://byteask.ai/install#editors) ByteAsk runs in the terminal on your laptop. Send yourself the install command and run it at your desk. Source: https://byteask.ai/ --- # Build the coding agent for C and C++ We build the C and C++ agent that proves each change against the toolchain. Backed by [Y Combinator](https://www.ycombinator.com/companies/byteask?utm_source=byteask_website&utm_medium=referral) and [Entrepreneur First](https://www.joinef.com/) · [Meet the founders](https://byteask.ai/team) [All roles](https://byteask.ai/careers#roles) ## Founding C++ Systems Engineer Engineering · Full-time · Hours overlapping San Francisco $150K to $200K + 0.5% to 2.0% equity [Apply for this role](https://byteask.ai/careers#apply) Own the part of the agent that decides whether a C or C++ patch is actually correct. ByteAsk runs each patch under a debugger, the sanitizers and a profiler, and reworks the diff until the toolchain agrees it is right. You run the tools a C++ engineer runs, read what they return, and choose the next step. Agents resolve roughly 63% of real-world issues in Python and under 10% in C and C++. You will be one of the first engineers, working directly with the founders. ### What you’ll do - Cross-translation-unit reasoning, where every public agent scores close to zero - Turning debugger, sanitizer and profiler output into a next move - Tool selection, including knowing when the honest answer is "we don't know" - Making the loop fast enough to live inside an edit cycle - On-prem deployments - Performance optimizations ### You may be a fit if - You have spent real years in C or C++ and know why the hard bugs are hard - You have read sanitizer output at 2am and gone to the codegen to settle an argument - You are comfortable owning an ambiguous problem with little guidance - You are sceptical of AI writing C++, and want to find out exactly where it breaks - You do not need an AI background. We would rather teach that half [Apply for this role](https://byteask.ai/careers#apply) ## Applying for Founding C++ Systems Engineer Source: https://byteask.ai/careers --- # ByteAsk Challenge Contribution Terms Effective October 2, 2026 · applies to Submissions through a ByteAsk challenge form These terms apply to every pull request, description, link or other material you submit through a ByteAsk challenge form ("Submissions"). ByteAsk, Inc. ("ByteAsk"). ## 1. Licence to ByteAsk You grant ByteAsk a worldwide, perpetual, irrevocable, royalty-free, fully paid, transferable and sublicensable licence to use, copy, modify, adapt, translate, create derivative works from, publish, display, distribute and otherwise exploit your Submissions, in any form and medium, for any purpose, including commercial purposes. This includes product development, demos, marketing, case studies, benchmarks, research, and training and evaluating machine-learning models. ## 2. Your name and work ByteAsk may publish, quote and feature your Submissions, your name, GitHub username, public profile picture and the outcome of your pull requests (merged, under review or closed), with or without attribution, in any medium, without further notice or payment. ## 3. Open-source projects This licence is in addition to the rights you grant the project you contribute to. It does not change those rights, and you keep whatever ownership you hold, subject to that project's licence and contributor terms. ## 4. Challenge data ByteAsk may use information about your participation, including how you used ByteAsk during the challenge, to judge your Submissions, run the challenge and improve ByteAsk. ## 5. Your promises Each Submission is your own work, or you have the right to submit it. It follows the licence, contributor terms and AI-use policy of the project it targets. It contains no confidential information, secrets or third-party material you are not allowed to share. ## 6. No obligation or payment Submissions are non-confidential. ByteAsk is not required to use, review or credit any Submission. You receive nothing for a Submission beyond any prizes or benefits ByteAsk publishes for the challenge. ## 7. Waiver To the extent the law allows, you waive any moral rights in your Submissions as they apply to ByteAsk's use. You also waive any claim against ByteAsk arising from its use of your Submissions under these terms. ## 8. General ByteAsk may update these terms; the version in force when you submit applies to that Submission. These terms are governed by the laws of the State of Delaware, USA. ## Contact Questions: [support@byteask.ai](mailto:support@byteask.ai) Source: https://byteask.ai/challenge-terms --- # Get in touch We read every message and usually reply within a day. - **Product & support:** Bugs, feature requests, or help getting started with the agent. [support@byteask.ai](mailto:support@byteask.ai) - **Plans & billing:** Changing plans, adding seats, invoices and charges. [contact@byteask.ai](mailto:contact@byteask.ai) - **Privacy:** Data handling, zero data retention, and compliance questions. [contact@byteask.ai](mailto:contact@byteask.ai) - **Security:** Vulnerability reports. [security@byteask.ai](mailto:security@byteask.ai) ## Tell us about you or your team Source: https://byteask.ai/contact --- # Cookie Policy Effective September 3, 2026 · applies to byteask.ai and the ByteAsk CLI ## The short version byteask.ai uses strictly necessary cookies only. We set no analytics cookies, no advertising cookies, and we do no cross-site tracking. There is nothing here for you to opt out of. We do measure how this site is used. Our analytics provider identifies visitors with a code generated on its own servers rather than with anything kept in your browser, which is why measuring you costs you no cookie and why there is no consent banner here. Session replays work the same way: the code that ties a replay to one page visit lives only in memory and is never written to your browser. The Privacy Policy lists exactly what is measured. ## Cookies we use A cookie is a small file a site keeps in your browser. The only cookies this site involves are the ones needed to serve it and keep it up. - Strictly necessary: required for the site to load and stay secure. Our infrastructure provider (Cloudflare) may set strictly necessary cookies, such as bot-protection cookies. These cannot be switched off. - Session storage: if you dismiss the announcement bar, the site remembers that in your browser for the rest of the session. It holds no identifier and leaves your device only when the tab closes. ## What we do not use No analytics cookies, no advertising or marketing cookies, no cross-site tracking, and no selling of data. We do not build advertising profiles about you. You can clear cookies and local storage for byteask.ai in your browser at any time. ## The CLI After you sign in, the ByteAsk CLI stores a short-lived authentication token in a local file on your machine. It is not a browser cookie and stays on your device except to authenticate your requests. ## Changes If this policy changes, the new version will be posted here with an updated effective date. ## Contact Questions about this document: [Contact us](https://byteask.ai/contact). Source: https://byteask.ai/cookies --- # Run ByteAsk inside your own network On-prem, air-gapped and bring-your-own-key deployments, with SAML SSO, SCIM, audit logs and model allowlists. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Talk to us](https://byteask.ai/enterprise#talk) # Managed: models through ByteAsk $ byteask login # Your keys: straight to the provider $ byteask byok set # Your server: vLLM, Ollama, llama.cpp, LM Studio $ byteask models add my-model --url http://your-host:8000 $ ## How a request travels Each path shows what stays inside your network and what leaves it. 1. ### Managed OpenAI, Anthropic and Google models through ByteAsk. No API key to paste. Your network Developer machine byteask CLI byteask login ByteAsk managed models provider API Model provider OpenAI, Anthropic, Google 2. ### Your keys Traffic goes straight to the provider, not through ByteAsk. Your network Developer machine byteask CLI byteask byok set Model provider OpenAI, Anthropic, Gemini 3. ### On-prem Including networks with no route to the internet. Your network Developer machine byteask CLI in your network ByteAsk gateway company API keys OpenAI API Your models vLLM, Ollama, llama.cpp ## What your admins get - **On-prem and air-gapped:** Run ByteAsk inside your network, including networks with no route to the internet. - **Your keys, your gateway:** Company API keys through a ByteAsk gateway in your network, with model and provider allowlists. - **SSO, SCIM and roles:** SAML single sign-on, SCIM provisioning and role-based access control. - **Audit logs:** Every session and tool call on record, with spend limits per user and per organization. - **Retention you set:** Custom data retention controls and IP allowlisting. - **DPA, SLA and purchase orders:** Data processing agreement, uptime SLA, invoicing and purchase orders. ## What happens to your code [Trust Center and security questionnaire](https://trust.byteask.ai) - **Zero data retention:** Your prompts and code are processed to answer the request, then dropped. Nothing is kept. [Read the privacy policy](https://byteask.ai/privacy) - **Not used to train models:** Your repositories are not used to train any model. Ours or anyone's. - **Passwordless sign-in:** A signed magic link logs you in. No password to manage, and nothing to paste or leak. ## Questions buyers ask Can we run it inside our own network? Yes, on the Enterprise plan: on-prem deployment including air-gapped networks, company API keys through a ByteAsk gateway in your network, SSO, SCIM, audit logs and IP allowlisting. Do I have to use your models? No. Sign in and use OpenAI, Anthropic and Google models through ByteAsk with no API key to paste, or bring your own key, in which case traffic goes straight to the provider. You can also point ByteAsk at your own OpenAI-compatible server, including vLLM, Ollama, llama.cpp, LM Studio, TGI, SGLang or a LiteLLM proxy. Which editors does it work in? VS Code, Cursor, JetBrains IDEs, Neovim, Emacs and Zed, plus Windsurf and VSCodium through Open VSX. Every connector needs the byteask CLI on your PATH, since the editor plugin drives the same CLI. ## Tell us about your team Or [book a demo](https://byteask.cal.com/pratyush/book-a-demo). Source: https://byteask.ai/enterprise --- # Built for teams where a C or C++ bug is expensive - [Trading and HFT Matching engines and feed handlers.ITCH/OUCH · FIX · PTP](https://byteask.ai/industries/trading-hft) - [Embedded and firmware Register-level code, cited from the datasheet.STM32 · CAN · Modbus](https://byteask.ai/industries/embedded) - [Automotive Rules looked up by number.AUTOSAR C++14 · MISRA](https://byteask.ai/industries/automotive) - [Silicon and FPGA Drivers written against the spec.AMBA AXI · UltraScale](https://byteask.ai/industries/silicon-fpga) - [Industrial, energy and test Inverters, instruments and plant controls.Modbus · IEEE 1547 · SCPI](https://byteask.ai/industries/industrial) - [Systems and OS Kernels, runtimes and toolchains.x86-64 SDM · ELF](https://byteask.ai/industries/systems) Source: https://byteask.ai/industries --- # For AUTOSAR C++14 code Looks up AUTOSAR C++14 rules by number, quotes them by page, runs clang-tidy and cppcheck. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it check a change](https://byteask.ai/industries/automotive#proof) ``` ByteAsk v0.1.12 tool: autosar_ref started {"query":"C++ Core Guidelines CP.3 minimize explicit sharing of writable data","limit":3} tool: autosar_ref (completed in 6254ms) 📚 autosar_ref · C++ Core Guidelines CP.3 minimize explicit sharing of wr… > If you don't share writable data, you can't have a data race. tool: cpp_check started {"path":".","timeout_sec":300,"use_compile_db":true} tool: cpp_check (completed in 29ms) 🔧 cpp_check · . No findings. tool: cpp_tidy started {"path":"bench/shard_replay.cpp","build_dir":"."} tool: cpp_tidy (completed in 1085ms) 🔧 cpp_tidy · bench/shard_replay.cpp No findings. ``` Recorded ByteAsk session on a C++ service: a guideline lookup with autosar_ref, then cpp_check and cpp_tidy on the changed code. ## AUTOSAR C++14 · MISRA ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. search_docs AUTOSAR C++14 Rule A18-5-1 functions malloc calloc realloc and free shall not be used ``` Rule A18-5-1 (required, implementation, automated) Functions malloc, calloc, realloc and free shall not be used. Rationale C-style allocation/deallocation using malloc/calloc/realloc/free functions is not type safe and does not invoke class’s constructors and destructors. Note that invoking free function on a pointer allocated with new, as well as invoking delete on a pointer allocated with malloc/realloc/calloc function, result in undefined behavior. Exception This rule does not apply to dynamic memory allocation/deallocation performed in user- defined overloads of new and delete operators or malloc and free functions custom implementations. ``` p.344 ref autosar_cpp14_guidelines_18-10:A18-5-1:614:0 · captured 2026-10-26 ## The tools it runs for Automotive - clang-tidy - cppcheck - CMake - gdb - ASan - Valgrind ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/automotive --- # For firmware and control loops Drives gdb to the store that corrupts a joint; cites the STM32 manual by page. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it find the bad store](https://byteask.ai/industries/embedded#proof) ``` {"action":"start","program":"~/byteask/cppcon/demos/04-runtime-forensics/build/armctl","args":"6000"} {"action":"cmd","session":1,"command":"print &g_joints[5].measured_rad"} $6 = (double *) 0x555555559280 {"action":"cmd","session":1,"command":"watch -location *(double*)0x555555559280"} Hardware watchpoint 2: -location *(double*)0x555555559280 {"action":"cmd","session":1,"command":"continue"} Old value = -1.9057374359644947 New value = -1.8236172821972838 {"action":"cmd","session":1,"command":"print this->joint_id_"} $8 = 5 {"action":"cmd","session":1,"command":"print g_joints[this->slot_].name"} $12 = "elbow\000\000" I have the concrete bad store: after reprioritization, controller `joint_id_=5` still targets `slot_=5`, and slot 5 now holds `elbow`. + for (int i = 0; i < kNumJoints; ++i) ctl[i].bind(static_cast(i)); /usr/bin/zsh -lc './build/armctl 20000' in ~/byteask/cppcon/demos/04-runtime-forensics completed, all joints within soft limits ``` Recorded ByteAsk session on armctl, a simulated arm controller: a hardware watchpoint catches the wrong joint being written. ## STM32 · CAN · Modbus ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. search_docs STM32F4 RM0090 general-purpose timer encoder interface mode TI1 polarity CC1P inverted counting direction ``` Figure 168. Example of counter operation in encoder interface mode forward jitter backward jitter forward TI1 TI2 Counter up down up MS33107V1 Figure 169 gives an example of counter behavior when TI1FP1 polarity is inverted (same configuration as above except CC1P=1). Figure 169. Example of encoder interface mode with TI1FP1 polarity inverted forward jitter backward jitter forward TI1 TI2 Counter down up ... ``` pp.613–614 ref dm00031020:1:184:24 · captured 2026-10-26 ## The tools it runs for Embedded and firmware - gdb - make - cppcheck - ASan and UBSan - Valgrind - Git ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/embedded --- # For instrument and inverter firmware Reproduces the bug on a simulated bench first, then cites IEEE 1547 and SunSpec Modbus. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it reproduce the bug](https://byteask.ai/industries/industrial#proof) ``` Fix this ticket. Add a regression test that turns the knob through the simulator bench, and make sure rev B still works. I’ll run `context_verify` now to confirm the new bench tests reproduce FP-251 before applying the fix. TESTS FAILED: built test_frontpanel (0 s), ran 1 test(s) (0 s) 0% tests passed, 1 tests failed out of 1 tests/test_frontpanel.c:39: CHECK_EQ(volume_get(), 23) failed: 17 != 23 tests/test_frontpanel.c:54: CHECK_EQ(freq_get(), 1000 + (i + 1) * 100) failed: 900 != 1100 not built: 6 other test program(s); none of them uses the code you changed The new test reproduced the reported result exactly: three clockwise clicks changed volume from 20 to 17. The fix is in place; I’ll use `context_verify` for rev C and `cpp_test_select` to run the bench, encoder, and key tests in the rev B build. PASS: built test_frontpanel, test_encoder_qei, test_knob (0 s), ran 3 test(s) (0 s) 100% tests passed, 0 tests failed out of 3 not built: 4 other test program(s); none of them uses the code you changed diff --git a/drivers/encoder/encoder_qei.c b/drivers/encoder/encoder_qei.c - /* Reverse in hardware: inverting TI1 flips the count direction at no cost. */ - hal_tim_encoder_init(cfg->tim, 0xFFFF, cfg->reverse); + /* Keep raw timer counts: encoder_detents() applies cfg->reverse for both drivers. */ + hal_tim_encoder_init(cfg->tim, 0xFFFF, false); ``` Recorded ByteAsk session on front-panel firmware for a bench signal source: a knob that turned the volume down when turned clockwise. ## Modbus · IEEE 1547 · SCPI ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. search_docs IEEE 1547-2018 voltage trip settings SunSpec Modbus point mapping OV2 clearing time ``` The table below contains the IEEE 1547-2018 required voltage trip adjustable settings, the associated IEEE 1547.1 results reporting label, and the SunSpec Modbus point mapping. IEEE Std 1547-2018 IEEE Std 1547.1-2020 RR SunSpec Modbus UV2 Voltage UV2_TRIP_V-AS 707.MustTrip.Crv.Pt[2].V UV2 Clearing Time UV2_TRIP_T-AS 707.MustTrip.Crv.Pt[2].Tms UV1 Voltage UV1_TRIP_V-AS 707.MustTrip.Crv.Pt[4].V UV1 Clearing Time UV1_TRIP_T-AS 707.MustTrip.Crv.Pt[4].Tms OV2 Voltage OV2_TRIP_V-AS 708.MustTrip.Crv.Pt[2].V OV2 Clearing Time OV2_TRIP_T-AS 708.MustTrip.Crv.Pt[2].Tms ``` pp.17–18 ref p0_1:2.10:11:3 · captured 2026-10-26 ## The tools it runs for Industrial, energy and test - CMake - cppcheck - clang-tidy - ASan and UBSan - gdb - Git ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/industrial --- # For FPGA and SoC teams Looks up the AXI4-Stream rule in the Arm spec before answering, with section and page. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it read the spec](https://byteask.ai/industries/silicon-fpga#proof) ``` in AXI4-Stream what's the difference between TKEEP and TSTRB, and is TKEEP allowed to be low in the middle of a packet? I’m checking the AXI4-Stream spec text directly so the answer is based on the wire-level definition, not memory. 📚 fpga_ref · AXI4-Stream TKEEP TSTRB null byte position data byte pos… I found the byte-qualifier definitions. I’m checking the packet rule next, because AXI4-Stream distinguishes generic packets from the stricter continuous-packet model. 📚 fpga_ref · AXI4-Stream packet boundaries null bytes within packet c… 📚 ref_context · D2_AMBA_AXI4Stream_IHI0051B:2.5:19:0_ _Not found: D2_AMBA_AXI4Stream_IHI0051B:2.5:19:0__ I have the main rule already; I’m pulling the exact valid `TKEEP/TSTRB` combinations so I can answer the first part precisely. 📚 fpga_ref · AXI4-Stream Table 2-3 HIGH LOW position byte LOW HIGH re… `TKEEP` and `TSTRB` answer different questions: - `TKEEP=1, TSTRB=1` -> data byte - `TKEEP=1, TSTRB=0` -> position byte - `TKEEP=0, TSTRB=0` -> null byte - `TKEEP=0, TSTRB=1` -> invalid/reserved On `TKEEP` being low in the middle of a packet: in generic AXI4-Stream, null bytes exist, so `TKEEP=0` is not inherently illegal. But in the `Continuous_Packets` subset, it is not allowed before the last transfer. From `fpga_ref`, the decisive rule is: `"If TLAST is LOW, all bits of TKEEP must be HIGH."` On the final beat, zeros are only allowed in the upper unused byte lanes. ``` Recorded ByteAsk session (byteask exec): a TKEEP and TSTRB question answered from the Arm AXI4-Stream spec. ## AMBA AXI · UltraScale ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. fpga_ref AXI4-Stream TKEEP TSTRB null byte position data byte position allowed middle of packet packet stream packet boundary TKEEP LOW middle ``` 2.5 Byte qualifiers 2.5.3 TKEEP and TSTRB combinations Table 2-3 lists the valid combinations for TKEEP and TSTRB byte qualifications. Not all components require TKEEP and TSTRB byte qualifiers. See Optional TKEEP and TSTRB on page 3-34. Table 2-3 TKEEP and TSTRB byte qualifications TKEEP TSTRB Data Type Description HIGH HIGH Data byte The associated byte contains valid information that must be transmitted between source and destination. HIGH LOW Position byte The associated byte indicates the relative position of the data bytes in a stream, but does not contain any relevant data values. LOW LOW Null byte The associated byte does not contain information and can be removed from the stream. ``` p.25 ref D2_AMBA_AXI4Stream_IHI0051B:2.5:19:0 · captured 2026-09-18 ## The tools it runs for Silicon and FPGA - gdb - AddressSanitizer - Valgrind - CMake - make - clang-tidy ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/silicon-fpga --- # For kernels, runtimes and toolchains Reads struct layout from the binary, measures before claiming a speedup, cites the x86-64 SDM. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it find the false sharing](https://byteask.ai/industries/systems#proof) ``` Find out why, and fix it. 🔧 cpp_layout · bench/shard_replay.cpp SymbolStats: size 32 (source: pahole (exact)) 0 messages (8 B) 8 shares (8 B) 16 notional (8 B) 24 last_price_ticks (4 B) 28 instrument_id (4 B) 0 of 32 bytes are padding (0%). No member straddles a 64B cacheline. 🔧 cpp_perf Method: plain timing (perf unavailable) (repeat=9, warmup=1 untimed) A: mean 0.1903s over 9 run(s) (±0.0016s stderr) B: mean 0.0795s over 9 run(s) (±0.0004s stderr) B is 2.39x faster than A (delta 0.1108s > noise gate 0.0041s; significant). -struct SymbolStats { +struct alignas(64) SymbolStats { ``` Recorded ByteAsk session on a four-shard benchmark: two instruments on one 64-byte cache line, fixed with one word and measured against a noise gate. ## x86-64 SDM · ELF ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. search_docs x86 SDM cache line fill 64-byte aligned cache line MESI shared invalid snoop write by another processor ``` When operating in an MP system, IA-32 processors (beginning with the Intel486 processor) and Intel 64 processors have the ability to snoop other processor’s accesses to system memory and to their internal caches. They use this snooping ability to keep their internal caches consistent both with system memory and with the caches in other processors on the bus. For example, in the Pentium and P6 family processors, if through snooping one processor detects that another processor intends to write to a memory location that it currently has cached in shared state, the snooping processor will invalidate its cache line forcing it to perform a cache line fill the next time it accesses the same memory location. ``` p.3618 ref 325462-091-sdm-vol-1-2abcd-3abcd-4-v2-1:14.2:545:2 · captured 2026-10-26 ## The tools it runs for Systems and OS - perf - Callgrind - gdb - readelf - objdump - make ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/systems --- # For matching engines and feed handlers Joins your open gdb session, finds the lock-order inversion, cites ITCH and FIX by section. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [See it find the deadlock](https://byteask.ai/industries/trading-hft#proof) The deadlock is found and fixed. **ByteAsk**AI pair-debugger done ❯ byteask "my gdb is stopped on the deadlock in orderd, take a look" ● Joined the bridge in your gdb. orderd is stopped. ▸ Two threads are stuck in __lll_lock_wait with no progress since 09:31. ▸ T7 (match) is blocked in OrderBook::cancel at order_book.cpp:214. ▸ T7 holds book_mtx_ and waits on risk_mtx_, owned by LWP 71154. ▸ T12 holds risk_mtx_ and waits on book_mtx_, owned by LWP 71149. ▸ That is a lock-order inversion between cancel() and on_fill(). ✎ order_book.cpp -std::lock_guard bk(book_mtx_); -std::lock_guard rk(risk_mtx_); +std::scoped_lock lk(book_mtx_, risk_mtx_); ▸ The same change is applied in risk_engine.cpp:87. $ ninja -C build && ./build/stress --orders 5000000 --threads 16 ✓ 5000000 orders, 0 stalls ▸ I want to run detach in your gdb. Approve? [y/n] ▸ Approved. Sent to your gdb. ✓The diff is ready for review. **gdb**your gdb, bridge armed detached (gdb) source ~/.byteask/byteask_gdb_bridge.py your session · 09:36 (gdb) byteask-bridge ByteAsk bridge armed. The AI can attach now. [byteask] (gdb) info threads Id Target Id Frame * 1 LWP 71142 "orderd" epoll_wait () 2 LWP 71143 "io" io_uring_enter () 7 LWP 71149 "match" __lll_lock_wait () 9 LWP 71151 "md_feed" recvmsg () 12 LWP 71154 "risk" __lll_lock_wait () [byteask] (gdb) thread 7 [Switching to thread 7 (LWP 71149 "match")] [byteask] (gdb) bt #0 __lll_lock_wait () #1 ___pthread_mutex_lock () #2 std::mutex::lock () at bits/std_mutex.h #3 OrderBook::cancel (this=0x55d1a3f2c8e0, id=88213004) at order_book.cpp:214 [byteask] (gdb) frame 3 #3 OrderBook::cancel (this=0x55d1a3f2c8e0, id=88213004) at order_book.cpp:214 [byteask] (gdb) p risk_mtx_._M_mutex.__data.__owner $1 = 71154 ← held by T12 [byteask] (gdb) thread 12 [Switching to thread 12 (LWP 71154 "risk")] [byteask] (gdb) bt #0 __lll_lock_wait () #1 ___pthread_mutex_lock () #2 std::mutex::lock () at bits/std_mutex.h #3 RiskEngine::on_fill (this=0x55d1a3f30120, fill=...) at risk_engine.cpp:87 [byteask] (gdb) p book_mtx_._M_mutex.__data.__owner $2 = 71149 ← held by T7 · cycle confirmed [byteask] (gdb) detach Detaching from program: /srv/orderd, process 71142 [Inferior 1 (process 71142) detached] (gdb) Recorded ByteAsk session on a trading service stopped in gdb: the orderd deadlock. ## ITCH/OUCH · FIX · PTP ByteAsk looks this up in the source and quotes it exactly, so it does not answer from memory. hft_ref Nasdaq TotalView-ITCH 5.0 Add Order No MPID Attribution message type A field layout length offsets page ``` Add Order Message Name Offset Length Value Notes Message Type 0 1 “A” Add Order – No MPID Attribution Message. Stock Locate 1 2 Integer Locate code identifying the security Tracking Number 3 2 Integer Nasdaq internal tracking number Timestamp 5 6 Integer Nanoseconds since midnight. Order Reference 11 8 Integer The unique reference number assigned to the new order at Number the time of receipt. Buy/Sell Indicator 19 1 Alpha The type of order being added. “B” = Buy Order. “S” = Sell Order. Shares 20 4 Integer The total number of shares associated with the order being added to the book. Stock 24 8 Alpha Stock symbol, right padded with spaces ``` p.13 ref E1_Nasdaq_ITCH-5.0:1.3:4:1 · captured 2026-09-11 ## The tools it runs for Trading and HFT - gdb - ThreadSanitizer - perf - Valgrind - CMake - clang-tidy ## See it on your own build [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) [Install](https://byteask.ai/#install) [On-prem and air-gapped: see Enterprise](https://byteask.ai/enterprise) Source: https://byteask.ai/industries/trading-hft --- # Install Install the ByteAsk coding agent for C and C++ in one line. Linux, macOS and Windows. Removal steps are below. ## The command Linux / macOS `~ ❯ curl -fsSL https://code.byteask.ai/install.sh | sh` Windows `PS> irm https://code.byteask.ai/install.ps1 | iex` ### Or from a package manager pip `~ ❯ pip install byteask` uv `~ ❯ uv tool install byteask` npm `~ ❯ npm i -g @byteask/cli` ### The short URL `byteask.ai/install` redirects to the script, so keep the `-L`. In a Dockerfile or CI job, use the canonical `code.byteask.ai` command above. `~ ❯ curl -fsSL byteask.ai/install | sh` ## After installing Open a terminal in your C or C++ project. ByteAsk emails you a sign-in link; there is no password. 1.Sign in `~ ❯ byteask login` 2.Ask about your code `~ ❯ byteask "explain this repo"` ## What the installer does Read off the two live scripts. Nothing here is inferred. ### Linux and macOS, `install.sh` Platforms Linux and macOS, on x86_64 or arm64. Any other `uname` exits with an error before anything is downloaded. On Windows the script tells you to use WSL, or use the PowerShell installer below. Install directory Your `PREFIX` if you set one, otherwise `/usr/local/bin` when that is already writable by you, otherwise `~/.local/bin`. The script never elevates to create it. What lands there Two executables, `byteask-engine` and the `byteask` launcher (a small POSIX shell script), plus a `.engine-release` marker file recording which release asset produced the engine, so a later update can skip a download it does not need. Directories created The install directory, `~/.byteask` (or `BYTEASK_HOME`), and `~/.byteask/skills/compress` and `~/.byteask/skills/terse` for the two bundled skills. Files in ~/.byteask A `gateway` file, a `config.toml`, a downloaded `models-catalog.json`, the own-key sidecar and its translator modules, a `SKILL.md` per skill, and a one-shot `referral` file if you passed `--ref=`. An existing login token is read out of the old `config.toml` and written back into the new one, so an update does not sign you out. Shell startup files Not touched. The script does not append to `.bashrc`, `.zshrc`, or any other startup file. If the install directory is not already on your `PATH` it prints the `export` line and leaves you to add it. ~/.gdbinit One block is appended, wrapped in marker comments and skipped if the marker is already present, so re-running does not duplicate it. The block sources `~/.byteask/byteask_gdb_bridge.py` when that file exists, which is what defines the `byteask-bridge` gdb command. The block's own comment says nothing is armed until you run that command, and that you disable it by deleting the block or running `byteask --uninstall-gdb-bridge`. sudo Two best-effort package installs, each only when the tool is missing. On Linux: `bubblewrap` (the sandbox the engine uses for model-run shell commands) and `ripgrep`, through whichever of apt-get, dnf, yum, pacman, zypper or apk is present, prefixed with `sudo` when you are not root. On macOS bubblewrap is skipped entirely and ripgrep goes through `brew`, with no sudo. Every one of those branches swallows its exit code, so a failure is never fatal: the script prints a note and carries on. Checksums Before each candidate download the script fetches `SHA256SUMS` from the same source. If the manifest lists that asset and the digest disagrees, the file is deleted and refused outright. If the manifest is unreachable or does not list the asset, the install continues with a printed note. Set `BYTEASK_REQUIRE_SHA256=1` to make a missing entry fatal as well. Either way every download must also clear a size floor of roughly 20 MB and an ELF or Mach-O magic-byte check. Where the engine comes from The release assets at [github.com/ByteAsk/cli](https://github.com/ByteAsk/cli/releases/latest) first, with code.byteask.ai as the fallback if that is unreachable. It walks a compressor ladder, `.zst` then `.xz` then `.gz` then the uncompressed asset, using only the decompressors actually on your PATH. The `byteask` launcher script itself comes from `BUNDLE_URL`, which is code.byteask.ai unless you override it. Install ping One short request to `/byteask/dl/-`, code.byteask.ai by default, capped at 3 seconds and ignoring failure. The script's comment calls it the per-platform install signal. Environment overrides `PREFIX`, `BYTEASK_HOME`, `ENGINE_URL`, `BUNDLE_URL`, `GATEWAY_URL`, `MODEL` (the model id written into config.toml), `BYTEASK_REQUIRE_SHA256`, `BYTEASK_FORCE_ENGINE_DOWNLOAD`, and `BYTEASK_REF`. All are read from the environment with a default, so exporting one before the pipe is enough. ### Windows, `install.ps1` Platforms 64-bit Windows only. The script errors out on a 32-bit OS. It runs under the built-in Windows PowerShell 5.1 or pwsh 7. Install directory Your `PREFIX` if set, otherwise `%LOCALAPPDATA%\Programs\ByteAsk`. What lands there `byteask-engine.exe`, a `byteask.ps1` wrapper, a `byteask.cmd` shim so the command works from any shell, and the same `.engine-release` marker. PATH This one does edit your environment: if the install directory is not already in your user `Path`, it is appended to the registry-backed user PATH. The script tells you to open a new terminal to pick it up. Config `%USERPROFILE%\.byteask` (or `BYTEASK_HOME`) gets the same set of files as the Unix installer: gateway, config.toml, model catalog, the own-key sidecar and translators, and the two skills. An existing login token is carried across. Elevation None. Ripgrep is attempted through winget, scoop or choco if one of them is on PATH, inside a try/catch, and a failure only prints a note. There is no `~/.gdbinit` step on Windows. Checksums The same policy as the shell installer: a listed digest that disagrees is refused, an absent manifest is a printed note, and `BYTEASK_REQUIRE_SHA256=1` makes absence fatal. Downloads must also clear the 20 MB floor and an `MZ` magic-byte check. ## Verify the script 1.Download it `~ ❯ curl -fsSLO https://code.byteask.ai/install.sh` 2.Read it `~ ❯ less install.sh` 3.Run the copy you read `~ ❯ sh install.sh` ## Uninstall No `--uninstall` flag yet. Delete what the installer created: Executables Delete `byteask`, `byteask-engine` and `.engine-release` from your install directory: `PREFIX`, otherwise `/usr/local/bin` or `~/.local/bin`. ~/.byteask Delete it (or `BYTEASK_HOME`): config, model catalog, sidecar files and skills. ~/.gdbinit Delete the ByteAsk block, from the marker comment to the matching end marker. Windows Delete `%LOCALAPPDATA%\Programs\ByteAsk` (or your `PREFIX`) and `%USERPROFILE%\.byteask`, then remove the install directory from your user `Path`. Left behind bubblewrap and ripgrep stay installed; remove them with your package manager. Shell startup files on Unix are never touched. ## Editors The CLI does the work; these connectors bring it into your editor. - VS Code Marketplace Live [Open in Marketplace](https://marketplace.visualstudio.com/items?itemName=byteask.byteask-vscode) `~ ❯ code --install-extension byteask.byteask-vscode` - Cursor Open VSX Live [Open in Open VSX](https://open-vsx.org/extension/byteask/byteask-vscode) `~ ❯ cursor --install-extension byteask.byteask-vscode` - JetBrains CLion, IDEA, PyCharm Live [Get on the Marketplace](https://plugins.jetbrains.com/plugin/32655-byteask) - Neovim lazy.nvim / packer Live [View the plugin](https://github.com/ByteAsk/ByteAsk.nvim) `{ 'ByteAsk/byteask.nvim' }` - Emacs use-package, vc Live [Emacs setup](https://github.com/ByteAsk/byteask-extensions/tree/main/emacs) - Zed Coming to the registry Soon [Track progress](https://github.com/ByteAsk/byteask-extensions/tree/main/zed) Source: https://byteask.ai/install --- # Assign a ticket. *Get a pull request.* Mention it in Jira, Linear, Slack or Teams. The pull request arrives built, tested, reviewed. [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) Jira *CORE-1482* Slack *# orderd-oncall* ## Where it runs - **Source control:** Including GitHub Enterprise Server, GitLab self-managed and Bitbucket Data Center. - GitHub - GitLab - Bitbucket - **Issues:** - Jira - Linear - **Chat:** - Slack - Microsoft Teams - **CI:** Run headless on every push with byteask exec. - GitHub Actions - GitLab CI - Jenkins - Buildkite - **Docs:** - Confluence - **Editors:** - VS Code - Cursor - JetBrains - Neovim - Emacs - Zed ## It builds the branch, then reviews it. - **Builds the branch first:** - **Evidence on the line:** - **A fix you can commit:** - **Your rules:** `$ byteask exec -o review.md "review this branch"` GitHub *pull request #311* Source: https://byteask.ai/integrations --- # Pricing ## Free Try ByteAsk on your C and C++ code. $0 [Get started](https://byteask.ai/#install) Your own API key Full access for 14 days ByteAsk's models Limited About 25 agent tasks a month Limited - Debugging - Memory and UB checks - Performance Unlimited - Build and test - Code quality - Compiler insight - Grounded docs - Community support ## Pro Popular For engineers who use ByteAsk every day. $16 Per month with annual subscription discount ($192 billed up front). $20 if billed monthly. [Start Pro](https://byteask.ai/contact) Your own API key Unlimited ByteAsk's models $20 of usage every month - Build and test - Debugging - Memory and UB checks - Performance - Code quality - Compiler insight - Grounded docs - Frontier models - Priority runs - Email support ## Max For heavy daily use. $100/month [Start Max](https://byteask.ai/contact) Your own API key Unlimited ByteAsk's models 5x the usage of Pro - Everything in Pro - Highest priority runs - Fast mode and early access to new features ## Ultra For running agents all day. $200/month [Start Ultra](https://byteask.ai/contact) Your own API key Unlimited ByteAsk's models 10x the usage of Pro - Everything in Max - Faster support Companies with more than 10 people need Team or Enterprise to use their own models. Questions? [Contact us](https://byteask.ai/contact) Source: https://byteask.ai/pricing --- # Privacy Policy Effective September 3, 2026 · applies to byteask.ai and the ByteAsk CLI ## Who we are ByteAsk, Inc. ("ByteAsk") provides an AI coding agent for C and C++ that runs in your terminal, together with this website. This policy covers both. ## What we collect - Your email address, when you sign in with a magic link. - A short-lived authentication token stored on your device after sign-in. - Minimal operational metadata about requests (timestamps, status, token counts) used for reliability, abuse prevention, and billing of credits. ## What we do not keep The prompts you type and the repository content the CLI sends are processed in memory to answer your request and are then dropped. We operate with zero data retention for prompts and code. Your code and prompts are not used to train any model. Ours or anyone’s. ## Model providers To answer a request, our gateway forwards your prompt and the repository context the CLI sends to the provider serving the model you selected: OpenAI, Anthropic, or Google. If you bring your own key or point ByteAsk at your own model server, that traffic goes directly from your machine to your provider or server and does not pass through us. ## Email delivery Sign-in links are delivered through a transactional email provider. Your email address is shared with that provider only to deliver the message. ## This website byteask.ai sets no advertising cookies and does no cross-site tracking. Our infrastructure provider (Cloudflare) may process connection data such as IP addresses to serve and protect the site. We use PostHog (hosted in the United States) to understand how the site is used. It records which pages you view, how long you stay, what you click, how far you scroll, how quickly the page loaded, the referring site, and the browser type. It does not record your location. These requests go through our own domain rather than a third-party address. Your identity is a code generated on PostHog's servers, not stored on your device. No cookie is set and nothing about you is kept in your browser for this, so we do not ask for consent. We also record sessions: once you move your mouse, scroll, tap or type on a page, PostHog captures a replay of that page visit so we can see where visitors get stuck. Text typed into form fields is masked and never recorded. A replay is tied to a single page visit by a random code held only in memory, so it is not linked to your other visits and is gone from your browser when you leave the page. We do not record automated traffic. Replays are kept for 30 days. If a page on this site hits a JavaScript error, we record the error message, the place in our code where it happened, and the page you were on, so that we can fix it. We do not record the contents of anything you type into a form. If you dismiss the announcement bar, that choice is kept in your browser's session storage until the tab is closed. It holds no identifier. ## The installer and the CLI - When you run the install script it makes one request to code.byteask.ai that names your operating system and CPU architecture, so we can count installs per platform. It carries no account information. - The CLI checks code.byteask.ai for a newer version when it starts. The request carries no account information. - When you sign in, the CLI asks our gateway whether an account exists for the email address you typed, to choose between sign-in and account creation. ## Payments Paid plans are billed through Razorpay, our payment processor. Razorpay handles your card details under its own privacy policy; we receive confirmation of payment and the plan purchased, not your card number. ## Retention and your rights We keep your account email while your account is active. You can request access to or deletion of your data at any time by writing to contact@byteask.ai, and we will act on the request promptly. ## Changes If this policy changes, the new version will be posted here with an updated effective date. ## Contact Questions about this document: [contact@byteask.ai](mailto:contact@byteask.ai) Source: https://byteask.ai/privacy --- # Knows what your build compiles. *Proves every change before you see it.* ByteAsk is an AI coding agent for C and C++ that runs your compiler, sanitizers, gdb and tests on its own changes. [Install](https://byteask.ai/#install) [Book a demo](https://byteask.cal.com/pratyush/book-a-demo) The deadlock is found and fixed. **ByteAsk**AI pair-debugger done ❯ byteask "my gdb is stopped on the deadlock in orderd, take a look" ● Joined the bridge in your gdb. orderd is stopped. ▸ Two threads are stuck in __lll_lock_wait with no progress since 09:31. ▸ T7 (match) is blocked in OrderBook::cancel at order_book.cpp:214. ▸ T7 holds book_mtx_ and waits on risk_mtx_, owned by LWP 71154. ▸ T12 holds risk_mtx_ and waits on book_mtx_, owned by LWP 71149. ▸ That is a lock-order inversion between cancel() and on_fill(). ✎ order_book.cpp -std::lock_guard bk(book_mtx_); -std::lock_guard rk(risk_mtx_); +std::scoped_lock lk(book_mtx_, risk_mtx_); ▸ The same change is applied in risk_engine.cpp:87. $ ninja -C build && ./build/stress --orders 5000000 --threads 16 ✓ 5000000 orders, 0 stalls ▸ I want to run detach in your gdb. Approve? [y/n] ▸ Approved. Sent to your gdb. ✓The diff is ready for review. **gdb**your gdb, bridge armed detached (gdb) source ~/.byteask/byteask_gdb_bridge.py your session · 09:36 (gdb) byteask-bridge ByteAsk bridge armed. The AI can attach now. [byteask] (gdb) info threads Id Target Id Frame * 1 LWP 71142 "orderd" epoll_wait () 2 LWP 71143 "io" io_uring_enter () 7 LWP 71149 "match" __lll_lock_wait () 9 LWP 71151 "md_feed" recvmsg () 12 LWP 71154 "risk" __lll_lock_wait () [byteask] (gdb) thread 7 [Switching to thread 7 (LWP 71149 "match")] [byteask] (gdb) bt #0 __lll_lock_wait () #1 ___pthread_mutex_lock () #2 std::mutex::lock () at bits/std_mutex.h #3 OrderBook::cancel (this=0x55d1a3f2c8e0, id=88213004) at order_book.cpp:214 [byteask] (gdb) frame 3 #3 OrderBook::cancel (this=0x55d1a3f2c8e0, id=88213004) at order_book.cpp:214 [byteask] (gdb) p risk_mtx_._M_mutex.__data.__owner $1 = 71154 ← held by T12 [byteask] (gdb) thread 12 [Switching to thread 12 (LWP 71154 "risk")] [byteask] (gdb) bt #0 __lll_lock_wait () #1 ___pthread_mutex_lock () #2 std::mutex::lock () at bits/std_mutex.h #3 RiskEngine::on_fill (this=0x55d1a3f30120, fill=...) at risk_engine.cpp:87 [byteask] (gdb) p book_mtx_._M_mutex.__data.__owner $2 = 71149 ← held by T7 · cycle confirmed [byteask] (gdb) detach Detaching from program: /srv/orderd, process 71142 [Inferior 1 (process 71142) detached] (gdb) ## ByteAsk builds the context. *The model gets the answer.* It replays your build and maps every function, template and call. The model gets only the few functions that matter. Bug #1982 in nlohmann/json, a popular C++ library. Each dot is a function, each line a call. The ringed dot is where ByteAsk points first. source files compiled 43 files in the project 77 lines of code 57,234 functions 907 classes 184 template versions 20,463 function calls 1,762 to build the index 2 min 16 s | Bugs | Model alone | With ByteAsk | | --- | --- | --- | | 80 bugs fixed 18 Aug to 22 Oct 2026 across 21 C/C++ projects | 50.9% | 66.7% | | 129 Multi-SWE-bench C++ bugs | 36% | 54% | ## It joins the gdb session you already have open. Linux allows one debugger per process. ByteAsk uses a bridge you start in yours. ``` ~/orderd ❯ claude "my gdb is stopped on the deadlock in orderd, take a look" Your gdb is holding the process. $ gdb -p -batch -ex bt warning: process is already traced by process ptrace: Operation not permitted. One tracer per process. The kernel refuses a second debugger while yours is attached. ``` ``` ~/orderd ❯ byteask "my gdb is stopped on the deadlock in orderd, take a look" Joined through the bridge you started. (gdb) bt #3 OrderBook::cancel (...) at order_book.cpp:214 (gdb) p risk_mtx_._M_mutex.__data.__owner $1 = 71154 (held by the risk thread) Your breakpoints are still set for the next turn. + std::scoped_lock lk(book_mtx_, risk_mtx_); ✓ Proposed, waiting for your approval. ``` your network your machine **gdb**your open session **byteask**the CLI **Tools**build, sanitizers, tests **ByteAsk gateway**company keys, allowlists **self-hosted models**vLLM, Ollama, llama.cpp ## The sanitizer names the line. ``` ~/demo/outputs ❯ g++ -O1 -g -fsanitize=address -fno-omit-frame-pointer order_book.cpp && ./order_book_asan ==2967905==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60c0000000c8 WRITE of size 4 at 0x60c0000000c8 thread T0 #0 0x55d75c82e5a6 in OrderBook::cancel_all() demo/outputs/order_book.cpp:31 #1 0x55d75c82e5a6 in main demo/outputs/order_book.cpp:42 #2 0x7feead645249 in __libc_start_call_main libc_start_call_main.h:58 0x60c0000000c8 is located 8 bytes to the right of 128-byte region allocated by thread T0 here: #0 0x7feeadcb94c8 in operator new(unsigned long) SUMMARY: AddressSanitizer: heap-buffer-overflow demo/outputs/order_book.cpp:31 ``` ``` ~/demo/outputs ❯ cmake -B build && cmake --build build && ctest --test-dir build Test project demo/outputs/build 1/3 Test #1: book_ops ......................... Passed 0.00 sec 2/3 Test #2: risk_engine ...................... Passed 0.00 sec 3/3 Test #3: wire_codec ....................... Passed 0.00 sec 100% tests passed, 0 tests failed out of 3 Total Test time (real) = 0.01 sec ``` ## The tools you already run **byteask***the CLI* - ### It builds your tree before it edits it - clangd - CMake - Compiler Explorer - C++ Insights - ### ASan, gdb and rr, on your process - ASan - gdb - lldb - Valgrind - rr - ### Your .clang-tidy, not ours - clang-tidy - clang-format - cppcheck - ### perf, before you see a diff - perf - Callgrind - QuickBench - ### objdump, when there is no source - objdump - nm - readelf ## Your key, or your own server - **Managed:** Sign in and use OpenAI, Anthropic and Google models through ByteAsk. No API key to paste. `$ byteask login` - **Your key:** Use your own OpenAI, Anthropic or Gemini key. Traffic goes straight to the provider, not through ByteAsk. `$ byteask byok set` - **Your server:** Point ByteAsk at vLLM, Ollama, llama.cpp, LM Studio, TGI, SGLang or a LiteLLM proxy. Self-hosted models are not metered. `$ byteask models add my-model --url http://your-host:8000` ### Standards it can cite | Tool | Corpus | | --- | --- | | autosar_ref | AUTOSAR C++14 · MISRA · ISO C++ | | mcu_ref | STM32 · Cortex-M · Modbus · CAN | | fpga_ref | Xilinx UltraScale · AMBA AXI | | hft_ref | ITCH/OUCH · FIX · IEEE 1588 PTP | | grid_ref | IEEE 1547 · 2030.5 · SunSpec | | scpi_ref | SCPI · instrument manuals | | x86_ref | x86-64 Software Developer Manual | Source: https://byteask.ai/product --- # Founders Coding agents still fail on C and C++, so we started ByteAsk. ![Anirudha Kulkarni](https://byteask.ai/img/team/anirudha-320.webp) Co-founder, CEO ## Anirudha Kulkarni Leads product, customers, and native C and C++ tooling. IIT Delhi · Quantbox · Optiver Built a Python-to-C++ transpiler at Quantbox that took production strategy code from 1.5 seconds to 150 nanoseconds. Worked on Optiver's delta-one desk. [LinkedIn](https://www.linkedin.com/in/anirudha-kulkarni47/) ![Pratyush Saini](https://byteask.ai/img/team/pratyush-320.webp) Co-founder, CTO ## Pratyush Saini Leads the harness, retrieval, benchmarks, and model training. IIT Delhi · Simbian · ThirdAI Founding engineer at Simbian, building AI security agents that handle over a million incidents a year. At ThirdAI he led CPU-first training and inference, including the Bolt engine. [LinkedIn](https://www.linkedin.com/in/pratyush-saini-96108a1a7/) ## Culture Founders talk to customers themselves. Every hire owns a real piece of the product. Source: https://byteask.ai/team --- # Terms of Service Effective September 3, 2026 · applies to byteask.ai and the ByteAsk CLI ## The service ByteAsk is an AI coding agent for the terminal provided by ByteAsk, Inc. ("ByteAsk"). It edits code in your repositories and verifies changes using compilers, sanitizers, debuggers, and tests. ## Accounts You sign in with a magic link sent to your email. You are responsible for the security of your email account and of the device that holds your ByteAsk token. ## Acceptable use - Use the service only for lawful purposes and on code you have the right to work with. - Do not attempt to access other users’ data, probe or overload the service, or circumvent usage limits. ## Your code and outputs Your code remains yours. You grant ByteAsk the limited right to process it solely to provide the service, consistent with the Privacy Policy. Generated code is a draft that ByteAsk verifies with tools, but you are responsible for reviewing changes before you ship them. ## Credits and beta Beta credits are granted at our discretion and have no cash value. The service is provided as is, without warranties of any kind, and may change or be interrupted during the beta. ## Liability To the maximum extent permitted by law, ByteAsk is not liable for indirect or consequential damages arising from use of the service. ## Termination You may stop using the service at any time. We may suspend accounts that violate these terms. ## Contact Questions about this document: [Contact us](https://byteask.ai/contact). Source: https://byteask.ai/terms