Skip to content
Backed by Y Combinator
AI coding agent for C and C++

Writes C++. Proves it compiles, runs, and passes.

ByteAsk works in your terminal. It edits the code, runs the compiler, the sanitizers and your tests, and can drive the gdb session you already have open. You review the diff.

$ curl -fsSL https://code.byteask.ai/install.sh | sh
Zero data retention

Built-in support for

C/C++LLVMGCCclangCompiler ExplorergdbValgrindASan, UBSan, TSanperfmakeCMakeQuickBenchvcpkgConanGitLinux
Built-in C and C++ tools
Compilers, sanitizers, debuggers, profilers and binary analysis, each one a visible tool call.
Grounded reference corpora
Standards and datasheets returned as excerpts, or an explicit miss.
Intel intrinsics indexed
The full dataset, looked up rather than recalled.
Why ByteAsk

It does the work you would have checked anyway

It runs the compiler

Your flags, your build system. The diff you review has already been built.

It joins your gdb

Through a bridge you arm yourself, inside the session you already have open.

It shows the raw output

Frames, files and line numbers intact, so you can audit the reasoning.

It asks before it acts

Read-only commands run. Anything that changes state is proposed first.

The lockout

It joins the gdb session you already have open.

Linux allows one debugger per process. ByteAsk joins through a bridge you start in your gdb, reads the live state, and asks before it changes anything.

Your gdb is stopped on the bug, and you ask an agent for help.

A shell agentClaude CodeLocked out
claude, ~/orderd
❯ claude "my gdb is stopped on the deadlock in orderd, take a look"
Your gdb is holding the process.
$ gdb -p <pid> -batch -ex bt
✗warning: process <pid> is already traced by process <your-gdb>
✗ptrace: Operation not permitted.
One tracer per process. The kernel refuses
a second debugger while yours is attached.
ByteAskIn your session
byteask, ~/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 gdb holds the process. A second debugger is refused by the kernel. ByteAsk goes through the bridge you started.

your machineyour gdbthe bridge you armedbyteask CLIcpp tools, sanitizers, testsByteAsk gatewaymodel providerOpenAI, Anthropic, Googlebridgeyour requestmodel requestBYOK or self-hosted models: direct

How a session is wired.

Check it yourself: while your gdb holds a process, run gdb -p <pid> in another shell.

Evidence

You get the tool's full output.

ByteAsk builds with your flags, runs the sanitizers, and runs your tests. It hands back the raw report with the frames, files and line numbers intact, so you can check the agent's reasoning against the same evidence.

ASang++ -O1 -g -fsanitize=address -fno-omit-frame-pointer order_book.cpp && ./order_book_asan
==2967905==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60c0000000c8WRITE 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:580x60c0000000c8 is located 8 bytes to the right of 128-byte regionallocated by thread T0 here:    #0 0x7feeadcb94c8 in operator new(unsigned long)SUMMARY: AddressSanitizer: heap-buffer-overflow demo/outputs/order_book.cpp:31
g++ 12.2 with AddressSanitizer, captured 2026-09-03. Source and script in demo/outputs. The overflow is the one bug in order_book.cpp: cancel_all() walks the level array one iteration too far.
ctestcmake -B build && cmake --build build && ctest --test-dir build
Test project demo/outputs/build1/3 Test #1: book_ops .........................   Passed    0.00 sec2/3 Test #2: risk_engine ......................   Passed    0.00 sec3/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
ctest on the same tree, same run. The three demo tests from the same tree, each a plain executable that returns zero when it passes.

Nothing in these two blocks was typed by hand. They are what the tools printed.

The toolchain

Every tool call is visible

Each one runs as its own step you can see, with its arguments and its output, so nothing the agent does is hidden behind a summary.

Compile and navigate

It reads the project the way clangd does

Generates compile_commands.json, then navigates by symbol rather than by grep.

  • clangd
  • CMake
  • Compiler Explorer
  • C++ Insights
Find the bug

Sanitizers, debuggers and deterministic replay

ASan, UBSan, TSan and Valgrind, batch and stateful gdb or lldb, and rr for a trace you can replay.

  • ASan
  • gdb
  • lldb
  • Valgrind
  • rr
Static analysis

Your config, not ours

clang-tidy and clang-format read the .clang-tidy and .clang-format already in your tree.

  • clang-tidy
  • clang-format
  • cppcheck
Profiling

Measure, then change

perf and Callgrind for the real workload, QuickBench for a single function.

  • perf
  • Callgrind
  • QuickBench
Binary analysis

Down to the instruction

objdump, nm and readelf, PIE-aware symbolization, and decompilation when there is no source.

  • objdump
  • nm
  • readelf
Models

Use our models, 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

Reference documents it can cite

Built-in reference tools search these standards and datasheets and return the exact passage with a citation. If there is no match, they say so instead of guessing.

ToolCorpus
autosar_refAUTOSAR C++14 · MISRA · ISO C++
mcu_refSTM32 · Cortex-M · Modbus · CAN
fpga_refXilinx UltraScale · AMBA AXI
hft_refITCH/OUCH · FIX · IEEE 1588 PTP
grid_refIEEE 1547 · 2030.5 · SunSpec
scpi_refSCPI · instrument manuals
x86_refx86-64 Software Developer Manual
How it works

Four steps, then you are reviewing a diff

$ curl -fsSL https://code.byteask.ai/install.sh | sh

Or a plugin for 6 editors, all driving the same CLI.

Install

One command, or your editor.

Linux, macOS or Windows. Sign in with a link sent to your email.

macOS Apple SiliconLinux x86_64, arm64Windows native

Editors also on Windsurf and VSCodium via Open VSX. Every connector needs the byteask CLI on your PATH.

Pick your platform
$ curl -fsSL https://code.byteask.ai/install.sh | sh
Security

Your code stays yours.

Zero-retention by design. Your machine carries a short-lived token and nothing more.

Zero data retention

Your prompts and code are processed to answer the request, then dropped. Nothing is kept.

Read the privacy policy

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.

FAQ

The questions that decide it

Why use ByteAsk instead of Claude Code, Cursor or Codex?
It debugs your running program, not just your code, and it isn't tied to one lab. When something crashes, hangs or only fails sometimes, ByteAsk can join the gdb session you already have open (Claude Code and Codex can't: Linux allows one debugger per process), catch memory errors and races, replay a flaky failure step by step, and tell you when a speedup is just noise. And OpenAI, Google and open models sit behind one sign-in, switchable mid-session, or bring your own key.
Why can another agent not just run gdb on my process?
Linux gives each process exactly one tracer, and while your gdb is attached, that tracer is your gdb. A second debugger gets Operation not permitted from ptrace. An agent that shells out to gdb can still run it in batch mode on a process nobody is debugging, but it cannot join the session you are sitting in. ByteAsk connects through a bridge you start inside your own gdb, reads the stop state, and proposes any command that would change it. You can check the lockout yourself: while your gdb holds a process, run gdb -p <pid> in another shell.
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.
Does it count against my plan if I run my own model?
No. Self-hosted models are never metered by ByteAsk and do not count against your plan. With your own key, the traffic does not pass through ByteAsk at all.
Can it invent a register offset or a rule number?
The reference tools do not answer from model memory. They search a curated corpus of standards and datasheets and return the exact passage with a citation, and when there is no match they say so instead of guessing. That covers the class of fact that is hardest to check by eye: register offsets, MISRA and AUTOSAR rule numbers, MSR addresses and wire-protocol field offsets.
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.

Writes the change, then proves it compiles, runs and passes.

$ curl -fsSL https://code.byteask.ai/install.sh | sh
Get started See how it works