Minimal CLI Agent in C

A developer has created a minimal CLI agent in C that can perform tasks similar to Claude Code, using only 2MB of RAM and negligible CPU usage. The single-file program, named cgent, relies solely on libcurl and the OpenAI Responses API, supporting raw terminal mode for pasting, backspace, and multiline prompts. The developer wrote the code without AI assistance to maintain C skills, acknowledging potential memory safety bugs.

| // This is an entire CLI agent, it can do everything Claude code can do, using raw mode to support pasting, backspace, | | | // escape to cancel agents turn, and multiline prompts with Shift + enter, | | | // but with 2MB of RAM, neglibible CPU usage and one small C file. | | | // It is a single C file for the openai responses api, with no dependency other than libcurl, and an | | | // OPENAI API KEY env var. | | | // compile with cc -lcurl -o cgent this file.c then install where you please. | | | // AI USAGE - This code was written without AI agents, largely to maintain my c skills, as such it is likely to have | | | // memory safety bugs. | | | include <ctype.h | | | include <curl/curl.h | | | include <stdio.h | | | include <string.h | | | include <stdlib.h | | | include <unistd.h | | | include <termios.h | | | include <stdbool.h | | | define BUF SIZE 65536 | | | define INPUT SIZE 1024 1024 + 4096 | | | // A terminal read returns a keystroke or a paste burst, never a whole prompt. | | | // take prompt loops until stdin is drained and accumulates into prompt buffer, | | | // so this only bounds a single read 2 . | | | define READ SIZE 4096 | | | // Escaping can double every byte, so this bounds a prompt of PROMPT SIZE / 2. | | | // It is never written past what is typed, so untouched pages stay unmapped. | | | define PROMPT SIZE 1024 1024 | | | define CARRY SIZE 65536 | | | define RESPONSE ID LEN 55 | | | // Longest marker we search for; a chunk's final MARKER MAX bytes are carried | | | // over, so a marker split across chunks is seen on the next pass. | | | define MARKER MAX 40 | | | static const char MODEL = "gpt-5.6-luna"; | | | // Interpolated raw, so no quotes or newlines. Sent every request: previous response id | | | // does not carry instructions over, and a prefix that only sometimes holds them misses. | | | static const char INSTRUCTIONS = | | | "You are an AI agent, you have access to one tool, bash, use it in this " | | | "directory to see what's here yourself to answer solve my problems."; | | | static const char TOOLS JSON = | | | ",\"tools\": {\"type\":\"function\",\"name\":\"bash\"," | | | "\"description\":\"Run a bash command, returns stdout and stderr.\"," | | | "\"parameters\":{\"type\":\"object\",\"properties\":{\"command\":{\"type\":\"string\"}}," | | | "\"required\": \"command\" ,\"additionalProperties\":false},\"strict\":true} "; | | | static int tool call count; | | | static int input len; | | | static char input buffer INPUT SIZE ; | | | // The response body is parsed in place as it arrives and never accumulated. Only | | | // the tail that might hold a marker split across a chunk boundary, or a tool call | | | // that has not fully arrived, is carried over to the next chunk. | | | static char carry CARRY SIZE ; | | | static int carry len; | | | static bool in text, text esc, saw text; | | | // The id arrives mid-stream, but chaining from a cancelled turn leaves a function call | | | // with no output, which the next request rejects. Committed only on completion. | | | static char previous response id RESPONSE ID LEN + 1 , pending response id RESPONSE ID LEN + 1 ; | | | struct termios orig termios; | | | void wout const char str, int len { | | | write STDOUT FILENO, str, len ; | | | } | | | static void erase previous void { | | | static const char erase previous = "\x1b 1D \x1b 1D"; | | | wout erase previous, sizeof erase previous - 1 ; | | | } | | | static void safe exit void { | | | tcsetattr STDIN FILENO, TCSAFLUSH, &orig termios ; | | | } | | | static void enable raw mode void { | | | tcgetattr STDIN FILENO, &orig termios ; | | | struct termios raw = orig termios; | | | raw.c lflag &= ~ ECHO | ICANON ; | | | raw.c iflag &= ~ICRNL; | | | raw.c cc VMIN = 1; | | | raw.c cc VTIME = 0; | | | atexit safe exit ; | | | tcsetattr STDIN FILENO, TCSAFLUSH, &raw ; | | | } | | | / Return the number of characters on the last logical line. The prompt | | | buffer contains a JSON string body, so a newline is stored as "\\n" and a | | | quote/backslash may occupy two bytes. / | | | static int get line index const char prompt buffer, const char prompt end { | | | int line index = 0; | | | bool first line = true; | | | while prompt buffer < prompt end { | | | if prompt buffer == '\\' && prompt buffer + 1 < prompt end { | | | if prompt buffer 1 == 'n' { | | | line index = 0; | | | prompt buffer += 2; | | | first line = false; | | | continue; | | | } | | | if prompt buffer 1 == '"' || prompt buffer 1 == '\\' { | | | line index++; | | | prompt buffer += 2; | | | continue; | | | } | | | } | | | line index++; | | | prompt buffer++; | | | } | | | return line index + first line; | | | } | | | static void take prompt char read buffer, char prompt buffer { | | | int line index = 0; | | | char prompt pos = prompt buffer; | | | prompt pos = 0; | | | for int bytes read; | | | bytes read = read STDIN FILENO, read buffer, READ SIZE - 1 = 0; { | | | // read buffer is compared as a C string below, and is not zeroed between | | | // reads, so terminate what actually arrived. | | | read buffer bytes read = 0; | | | for int i = 0; i < bytes read; i++ { | | | char c = read buffer i ; | | | // No token appends more than two bytes plus the terminator. Once | | | // full, drop input rather than run off the end; editing keys still | | | // work, so the prompt can be cut back down. | | | bool full = prompt pos - prompt buffer + 3 PROMPT SIZE; | | | if iscntrl c && read buffer 0 = '\x1b' { | | | if full continue; | | | wout &c, 1 ; | | | switch c { | | | // The buffer is interpolated straight into the request as a | | | // JSON string, so escape here as newlines already are. | | | case '"': | | | case '\\': | | | prompt pos++ = '\\'; | | | } | | | prompt pos++ = c; | | | line index++; | | | } else { | | | switch c { | | | // backspace | | | case 127: | | | / A newline is two bytes in the JSON buffer, but one | | | terminal line break. Keep the buffer and cursor in | | | sync when deleting it. / | | | if prompt pos == prompt buffer | | | break; | | | if line index == 0 { | | | / At column zero the previous token is an escaped | | | newline. The empty-buffer check prevents moving | | | above the first line. / | | | if prompt pos - prompt buffer < 2 || | | | prompt pos -2 = '\\' || prompt pos -1 = 'n' | | | break; | | | prompt pos -= 2; | | | prompt pos = 0; | | | line index = get line index prompt buffer, prompt pos ; | | | / Cursor is at the start of the current line. / | | | printf "\x1b 1F" ; | | | if line index 0 | | | printf "\x1b %dC", line index ; | | | fflush stdout ; | | | break; | | | } | | | / Quotes and backslashes have an extra JSON byte. / | | | if prompt pos - prompt buffer = 2 && | | | prompt pos -2 == '\\' && | | | prompt pos -1 == '"' || prompt pos -1 == '\\' | | | prompt pos -= 2; | | | else | | | prompt pos--; | | | prompt pos = 0; | | | erase previous ; | | | line index--; | | | break; | | | case '\r': | | | //buffer | | | line index = 0; | | | wout "\n", 1 ; | | | if bytes read == i + 1 { | | | prompt pos = 0; | | | return; | | | } | | | if full break; | | | prompt pos++ = '\\'; | | | prompt pos++ = 'n'; | | | break; | | | case '\n': | | | //buffer | | | line index = 0; | | | wout "\n", 1 ; | | | if full break; | | | prompt pos++ = '\\'; | | | prompt pos++ = 'n'; | | | break; | | | default: | | | // Handle escape sequences, some terminals send this for shift + enter | | | // Shift + Enter | | | if strcmp read buffer, "\x1b 27;2;13~" { | | | if full { | | | prompt pos++ = '\\'; | | | prompt pos++ = 'n'; | | | } | | | wout "\n", 1 ; | | | line index = 0; | | | goto buffer parsed; | | | } | | | printf "%d\n", c ; | | | break; | | | } | | | } | | | } | | | buffer parsed:; | | | } | | | // read 2 failed; the caller still needs a terminated buffer. | | | prompt pos = 0; | | | } | | | static void wout codepoint unsigned int cp { | | | char b 4 ; | | | int n = 0; | | | if cp < 0x80 b n++ = cp; | | | else if cp < 0x800 { | | | b n++ = 0xC0 | cp 6; | | | b n++ = 0x80 | cp & 0x3F ; | | | } else if cp < 0x10000 { | | | b n++ = 0xE0 | cp 12; | | | b n++ = 0x80 | cp 6 & 0x3F ; | | | b n++ = 0x80 | cp & 0x3F ; | | | } else { | | | b n++ = 0xF0 | cp 18; | | | b n++ = 0x80 | cp 12 & 0x3F ; | | | b n++ = 0x80 | cp 6 & 0x3F ; | | | b n++ = 0x80 | cp & 0x3F ; | | | } | | | wout b, n ; | | | } | | | static enum { JSON TEXT, JSON ESC, JSON HEX } unescape state; | | | static unsigned int unescape cp, unescape high; | | | static int unescape hexlen; | | | static void reset json unescape void { | | | unescape state = JSON TEXT; | | | unescape cp = unescape high = 0; | | | unescape hexlen = 0; | | | } | | | // Unescapes a JSON string body straight to stdout. Holds only the few bytes of | | | // escape state needed to resume, so it can be fed arbitrary chunk boundaries. | | | static void print json unescaped const char src, int n { | | | for int i = 0; i < n; i++ { | | | char c = src i ; | | | switch unescape state { | | | case JSON TEXT: | | | if c == '\\' unescape state = JSON ESC; | | | else wout &c, 1 ; | | | break; | | | case JSON ESC: | | | unescape state = JSON TEXT; | | | switch c { | | | case 'n': wout "\n", 1 ; break; | | | case 't': wout "\t", 1 ; break; | | | case 'r': wout "\r", 1 ; break; | | | case 'b': wout "\b", 1 ; break; | | | case 'f': wout "\f", 1 ; break; | | | case 'u': | | | unescape cp = 0; | | | unescape hexlen = 0; | | | unescape state = JSON HEX; | | | break; | | | default: wout &c, 1 ; | | | } | | | break; | | | case JSON HEX: | | | unescape cp = unescape cp 16 + | | | c <= '9' ? c - '0' : c | 32 - 'a' + 10 ; | | | if ++unescape hexlen < 4 break; | | | unescape state = JSON TEXT; | | | if unescape cp = 0xD800 && unescape cp < 0xDC00 { | | | unescape high = unescape cp; | | | break; | | | } | | | if unescape high && unescape cp = 0xDC00 && unescape cp < 0xE000 | | | unescape cp = 0x10000 + unescape high - 0xD800 << 10 + | | | unescape cp - 0xDC00 ; | | | unescape high = 0; | | | wout codepoint unescape cp ; | | | } | | | } | | | } | | | // Appends src to dst as an escaped JSON string body, returns the new length. | | | static int json escape char dst, int len, const char src { | | | for ; src && len + 2 < INPUT SIZE; src++ { | | | switch src { | | | case '"': case '\\': dst len++ = '\\'; dst len++ = src; break; | | | case '\n': dst len++ = '\\'; dst len++ = 'n'; break; | | | case '\t': dst len++ = '\\'; dst len++ = 't'; break; | | | default: if unsigned char src = 0x20 dst len++ = src; | | | } | | | } | | | return len; | | | } | | | static void feed char chunk, int len, bool final ; | | | static void run agent char prompt, CURL curl, CURL multi { | | | static struct curl waitfd input = { | | | .fd = STDIN FILENO, | | | .events = CURL WAIT POLLIN, | | | .revents = 0 | | | }; | | | struct termios raw termios; | | | tcgetattr STDIN FILENO, &raw termios ; | | | char animation = "\x1b 1D "; | | | char c = 0; | | | raw termios.c cc VMIN = 0; | | | raw termios.c cc VTIME = 1; | | | tcsetattr STDIN FILENO, TCSAFLUSH, &raw termios ; | | | snprintf input buffer, INPUT SIZE, "\"%s\"", prompt ; | | | do { | | | curl multi add handle multi, curl ; | | | char previous json = NULL; | | | if previous response id | | | asprintf &previous json, ", \"previous response id\":\"%s\"", previous response id ; | | | // gpt-5.6 needs prompt cache key for reliable matching: without it an identical | | | // prefix routes by hash alone and lands elsewhere each turn. Every turn of a | | | // session shares the prefix, so one key per process; a reused pid costs a miss. | | | char json; | | | asprintf | | | &json, | | | "{\"model\":\"%s\",\"instructions\":\"%s\",\"prompt cache key\":\"cgent:%d\"" | | | ",\"input\":%s%s%s}", | | | MODEL, INSTRUCTIONS, int getpid , | | | input buffer, | | | TOOLS JSON, | | | previous json ? previous json : "" | | | ; | | | //printf "%s\n", json ; | | | curl easy setopt curl, CURLOPT POSTFIELDS, json ; | | | curl easy setopt curl, CURLOPT POSTFIELDSIZE, strlen json ; | | | tool call count = carry len = pending response id = 0; | | | in text = text esc = saw text = false; | | | int still running; | | | do { | | | CURLMcode mc = curl multi perform multi, &still running ; | | | if mc && still running && c = 27 { | | | // extra nfds must be 1, otherwise stdin is never polled, revents | | | // is never set, and ESC cannot cancel a stalled request. | | | mc = curl multi poll multi, &input, 1, 80, NULL ; | | | } | | | if input.revents & CURL WAIT POLLIN { | | | read STDIN FILENO, &c, 1 ; | | | input.revents = 0; | | | } | | | wout animation, sizeof animation - 1 ; | | | if animation 4 == '/' animation 4 = ' '; | | | animation 4 ++; | | | } while still running && c =27 ; | | | erase previous ; | | | // Drain the multi queue before removing the handle, otherwise a transport | | | // failure is silently indistinguishable from an empty reply. | | | CURLMsg msg; | | | for int queued; msg = curl multi info read multi, &queued ; | | | if msg- msg == CURLMSG DONE && msg- data.result = CURLE OK | | | printf "\x1b 31mcurl: %s\x1b 0m\n", | | | curl easy strerror msg- data.result ; | | | if c = 27 { | | | long code = 0; | | | curl easy getinfo curl, CURLINFO RESPONSE CODE, &code ; | | | if code && code = 200 { | | | printf "\x1b 31mHTTP %ld\x1b 0m\n%s\n", code, json ; | | | exit 1 ; | | | } | | | feed carry, 0, true ; | | | // Per iteration, not per turn: the tool loop attaches its output to this id. | | | if pending response id strcpy previous response id, pending response id ; | | | if saw text && tool call count | | | printf "\x1b 31m no text or tool call in response \x1b 0m\n" ; | | | fflush stdout ; | | | } | | | curl multi remove handle multi, curl ; | | | free json ; | | | free previous json ; | | | } while tool call count && c = 27 ; | | | raw termios.c cc VMIN = 1; | | | raw termios.c cc VTIME = 0; | | | tcsetattr STDIN FILENO, TCSAFLUSH, &raw termios ; | | | } | | | static void run repl CURL curl, CURL multi { | | | char read buffer = malloc READ SIZE ; | | | char prompt buffer = malloc PROMPT SIZE ; | | | for ;; { | | | wout " ", 1 ; | | | take prompt read buffer, prompt buffer ; | | | run agent prompt buffer, curl, multi ; | | | } | | | free read buffer ; | | | free prompt buffer ; | | | } | | | static void run tool char id, char id end, char src, char end { | | | // exec with only redirections applies them to the whole shell, so this holds | | | // however the command is structured. Detaching stdin is what matters: popen | | | // inherits our raw-mode terminal, so anything that reads stdin or prompts | | | // blocks the agent forever. 2 &1 also makes this match the tool description. | | | static const char prefix = "exec </dev/null 2 &1\n"; | | | static const int prefix len = sizeof prefix - 1; | | | // The prefix is reserved at the head of the buffer and the command parsed in | | | // directly after it, so the shell gets one buffer with no second copy. | | | static char shell command BUF SIZE , output BUF SIZE ; | | | memcpy shell command, prefix, prefix len ; | | | char command = shell command + prefix len; | | | int n = 0; | | | while src + 2 < end && src 0 == '\\' && src 1 == '"' && src 2 == '}' && | | | prefix len + n + 1 < BUF SIZE { | | | char c = src++; | | | if c == '\\' && src < end && src == '\\' { | | | src++; | | | c = src++; | | | if c == '\\' && src < end c = src++; | | | else if c == 'n' c = '\n'; | | | else if c == 't' c = '\t'; | | | else if c == 'r' c = '\r'; | | | } | | | command n++ = c; | | | } | | | command n = 0; | | | erase previous ; | | | printf "\x1b 90m$ %s\x1b 0m\n", command ; | | | fflush stdout ; | | | FILE pipe = popen shell command, "r" ; | | | int out len = 0; | | | bool truncated = false; | | | if pipe { | | | for ;; { | | | int space = int sizeof output - 1 - out len; | | | if space 0 { | | | int r = fread output + out len, 1, space, pipe ; | | | if r <= 0 break; | | | out len += r; | | | } else { | | | // Keep draining so the child is not killed mid-write by SIGPIPE. | | | char sink 4096 ; | | | if fread sink, 1, sizeof sink, pipe <= 0 break; | | | truncated = true; | | | } | | | } | | | pclose pipe ; | | | } | | | output out len = 0; | | | wout output, out len ; | | | if truncated wout "\n output truncated \n", 20 ; | | | if tool call count { | | | input buffer 0 = ' '; | | | input len = 1; | | | } | | | input len += snprintf input buffer + input len, INPUT SIZE - input len, | | | "%s{\"type\":\"function call output\",\"call id\":\"%. s\",\"output\":\"", | | | tool call count++ ? "," : "", int id end - id , id ; | | | input len = json escape input buffer, input len, output ; | | | if truncated | | | input len = json escape input buffer, input len, "\n output truncated " ; | | | input len += snprintf input buffer + input len, INPUT SIZE - input len, "\"}" ; | | | snprintf input buffer + input len, INPUT SIZE - input len, " " ; | | | } | | | // Finds the unescaped closing quote of a JSON string body. text esc carries the | | | // "previous byte was a backslash" state across calls so a split escape sequence | | | // is not mistaken for the terminator. | | | static char find string end char src, int n { | | | for int i = 0; i < n; i++ { | | | if text esc { text esc = false; continue; } | | | if src i == '\\' { text esc = true; continue; } | | | if src i == '"' return src + i; | | | } | | | return NULL; | | | } | | | // Parses src 0..n in place and returns the offset of the first byte that could | | | // not be consumed yet; the caller carries ret, n into the next chunk. With | | | // final set, everything is consumed. | | | static int parse chunk char src, int n, bool final { | | | int cur = 0; | | | for ;; { | | | char base = src + cur; | | | char end = src + n; | | | int avail = n - cur; | | | if avail <= 0 return n; | | | if in text { | | | // find string end carries its escape state, so text streams out with | | | // no lookahead at all. | | | char stop = find string end base, avail ; | | | print json unescaped base, stop ? stop : end - base ; | | | if stop return n; | | | wout "\n", 1 ; | | | in text = false; | | | cur = stop - src + 1; | | | continue; | | | } | | | char call = strnstr base, "\"type\": \"function call\"", avail ; | | | char rid = strnstr base, "\"id\": \"resp ", avail ; | | | char text = strnstr base, "\"text\": \"", avail ; | | | char first = NULL; | | | int kind = 0; | | | if call { first = call; kind = 1; } | | | if rid && first || rid < first { first = rid; kind = 2; } | | | if text && first || text < first { first = text; kind = 3; } | | | // No marker here, so one can only have been split across the boundary. | | | // Everything before the last MARKER MAX bytes is provably marker-free. | | | if first { | | | if final return n; | | | return avail MARKER MAX ? n - MARKER MAX : cur; | | | } | | | if kind == 1 { | | | // Bound the field search to this output item so a truncated item | | | // cannot borrow the next one's call id. | | | char item end = strnstr first + 1, "\"type\": \"function call\"", | | | end - first + 1 ; | | | if item end item end = end; | | | char id = strnstr first, "\"call id\": \"", item end - first ; | | | char command = strnstr first, "\"arguments\": \"{\\\"command\\\":\\\"", | | | item end - first ; | | | char id end = NULL, command end = NULL; | | | if id && command { | | | id += sizeof "\"call id\": \"" - 1; | | | command += sizeof "\"arguments\": \"{\\\"command\\\":\\\"" - 1; | | | id end = memchr id, '"', item end - id ; | | | command end = strnstr command, "\\\"}", item end - command ; | | | } | | | // Incomplete item: carry it whole and retry once the rest lands. | | | if id end || command end | | | return final ? n : first - src; | | | run tool id, id end, command, command end + 3 ; | | | cur = command end - src + 3; | | | continue; | | | } | | | if kind == 2 { | | | char id = first + sizeof "\"id\": \"" - 1; | | | // Wait until the whole id has arrived, otherwise the copy picks up | | | // bytes that are not part of it yet. | | | if end - id < RESPONSE ID LEN | | | return final ? n : first - src; | | | strncpy pending response id, id, RESPONSE ID LEN ; | | | cur = id - src + RESPONSE ID LEN; | | | continue; | | | } | | | // kind == 3: start of an output text value. | | | cur = first - src + sizeof "\"text\": \"" - 1; | | | in text = true; | | | saw text = true; | | | text esc = false; | | | reset json unescape ; | | | erase previous ; | | | } | | | } | | | // Parses a chunk together with whatever the last one carried over. Only the | | | // carry is ever copied; the body itself is parsed straight out of curl's buffer. | | | static void feed char chunk, int len, bool final { | | | char src = chunk; | | | int n = len; | | | if carry len { | | | if carry len + len CARRY SIZE { | | | printf "\x1b 31m tool call exceeds %d bytes \x1b 0m\n", CARRY SIZE ; | | | exit 1 ; | | | } | | | memcpy carry + carry len, chunk, len ; | | | src = carry; | | | n = carry len + len; | | | } | | | int keep = n - parse chunk src, n, final ; | | | if keep memmove carry, src + n - keep, keep ; | | | carry len = keep; | | | } | | | static size t write mem callback void contents, size t size, size t nmemb, void userp { | | | void userp; | | | int len = size nmemb; | | | feed contents, len, false ; | | | return len; | | | } | | | int main int argc, char argv { | | | void argc; | | | void argv; | | | CURL multi = curl multi init ; | | | CURL curl = curl easy init ; | | | if curl { | | | curl easy cleanup curl ; | | | exit -1 ; | | | } | | | curl easy setopt curl, CURLOPT URL, "https://api.openai.com/v1/responses" ; | | | struct curl slist list = NULL; | | | char api key = getenv "OPENAI API KEY" ; | | | if api key == NULL return -1; | | | char auth header = "Authorization: Bearer \0 "; | | | strcat auth header, api key ; | | | list = curl slist append | | | list, | | | auth header | | | ; | | | list = curl slist append list, "Content-Type: application/json" ; | | | curl easy setopt curl, CURLOPT HTTPHEADER, list ; | | | curl easy setopt curl, CURLOPT WRITEFUNCTION, write mem callback ; | | | curl easy setopt curl, CURLOPT CONNECTTIMEOUT, 20L ; | | | // No overall timeout: a long generation is legitimate. Give up only once the | | | // connection has stopped delivering anything at all. | | | curl easy setopt curl, CURLOPT LOW SPEED LIMIT, 1L ; | | | curl easy setopt curl, CURLOPT LOW SPEED TIME, 120L ; | | | enable raw mode ; | | | run repl curl, multi ; | | | curl easy cleanup curl ; | | | } |