I Built an OpenAI-Compatible Proxy for GitHub Copilot Because Search Was Too Stupid to Understand Norwegian Guitar Tabs

I named it agentry (because it gives an ai agent persistent entry)

Software projects are supposed to begin with a sensible problem and proceed toward a proportionate solution.

Mine began with:

“Why can’t I search for that bittersweet Trønderrock song about driving home from a funeral?”

Normal people would shrug and type a few more words.

I, being from Northern Norway and therefore apparently incapable of leaving a thing alone, built a semantic search engine, an LLM enrichment pipeline, and eventually an OpenAI-compatible proxy in front of GitHub Copilot CLI.

This is, objectively, a silly use of modern compute.

And yet.

The original problem: search is usually dumb

I have a hobby project called NorTabs-web, a static web app for browsing Norwegian guitar tabs.

Not Spotify. Not some venture-funded AI music startup. Just thousands of lovingly hand-transcribed guitar tabs from a Norwegian site, packed into one giant JSON blob and served in a browser like it’s 1999.
Load-time is a wee bit slow - content is about 7mb; About the same as a larg-ish image. Search/Drilldown is INSTANT however.

Raw search worked, in the usual way:

• title match
• artist match
• maybe a lyric fragment if you were lucky

But human memory doesn’t work like that.

People remember:

• “that melancholic Eurovision song”
• “a Trøndelag roadtrip vibe”
• “children’s songs”
• “that one line about wanting to earn money with my body”

The raw tab data does not contain “melancholic”, “roadtrip”, “Eurovision”, or “midlife crisis but with acoustic guitar”.

So substring search was not enough.

The entirely proportionate response: fifty thousand LLM calls

Naturally, I built an enrichment pipeline.

Each artist got metadata:

• genre
• era
• country
• region
• similar artists

Each song got:

• mood
• themes
• occasions
• alternate titles
• lyric phrases
• search-oriented semantic tags

This meant that searching for:

trondheim

could also match:

• trønderrock
• nidaros
• trondhjem
• trøndelag

And searching for:

melankolsk

might surface the right heartbreak song, even if the original tab never contained that word.

This required… somewhat more LLM calls than is emotionally healthy.

At one point I had scripts serializing enrichment runs across thousands of entries, checkpointing JSON, resuming partial runs, salvaging truncated model output, and retrying fallback entries.

There is Python in this project that exists purely to detect whether an LLM died halfway through a JSON object and then gently staple the braces back on like a field medic.

This may have been a warning sign.

The CLI overhead problem

My enrichment scripts originally used CLI tools in the simplest possible way:

LLM CLI -p "prompt"

Which works.

If by “works” you mean:

• spawn process
• initialize runtime
• load model plumbing
• authenticate
• run prompt
• tear everything down
• repeat ten thousand times

This is acceptable for casual use.

It is less charming when you are grinding through hundreds of enrichment calls because you want guitar-tab search to understand vibes.

At this point, even I had to admit that I was spending industrial amounts of machinery on a problem that would not survive first contact with a normal human conversation.

Discovering ACP

GitHub Copilot CLI has an ACP server mode.

ACP (Agent Client Protocol) is a proper JSON-RPC interface. Sessions, prompts, streamed updates, config options — actual protocol plumbing, not terminal scraping.

So naturally my brain went:

“Hm. If this is already a protocol, I can keep it alive.”

This is usually where projects start becoming strange.

The stupid little proxy that worked suspiciously well

I wrote a Python wrapper that:

• spawns one persistent copilot --acp
• speaks JSON-RPC over stdio
• keeps sessions alive
• translates responses into OpenAI-compatible HTTP endpoints
• streams deltas in SSE format
• denies tool requests to keep it chat-only

So now anything that speaks:

POST /v1/chat/completions

can talk to my local Copilot-backed proxy as if it were a normal OpenAI API.

This was supposed to be a weekend spike.

It worked quite a bit better than it had any right to.

My use case, which gets dumber the more I explain it

At this point, I had:

• a static Norwegian guitar-tab website
• an LLM enrichment pipeline
• a search engine with inverted indexes and semantic tags
• a local proxy translating Copilot ACP into OpenAI wire format

All because I wanted better search for chord sheets.

This is the sort of engineering story you tell and then pause so people can quietly reconsider your judgment.

In my defense, I am from Northern Norway.

We do not always stop when a thing becomes unreasonable. Sometimes we just put on a thicker jacket and continue.

Things I learned

1. CLI tools are often secretly protocols

A lot of “interactive” developer tools now sit on top of actual machine interfaces.

If you can find the protocol, you can often build smarter wrappers than the intended UX exposes.

ACP is a good example of that.

2. Persistent sessions matter more than you think

Process startup overhead is tolerable once.

Not 10,000 times.

Keeping the backend warm dropped latency from “why did I do this to myself” to “actually usable.”

3. Search becomes interesting when you stop treating words literally

Substring search is useful.

Semantic LLM enrichment makes search feel like memory.

That was the entire point of this exercise, buried underneath a mountain of accidental systems engineering.

4. The internet should probably not know about every hack

This proxy lives in a somewhat gray area.

It is a personal experiment.

It uses my own login.

It runs locally.

It is not a SaaS business, and Claude willing it never becomes one.

Some projects are best appreciated as engineering curiosities rather than product ideas.

Closing thoughts

People sometimes imagine software engineering as disciplined architecture guided by clear requirements.

Sometimes it is.

Sometimes it is:

“I need guitar-tab search to understand emotional context.”

…followed by:

• JSON-RPC
• SSE streaming
• semantic indexing
• quota-aware LLM pipelines
• recovery code for mutilated JSON
• OpenAI-compatible local proxies

And then, several weekends later, you look at the repo and think:

“Æ e faen ikke helt sikker på hvordan vi havna her.”

But the search works.

And, in fairness, that bittersweet Trønderrock song does show up now.

Which is more than can be said for my sense of proportion.

Code: github.com/aweussom/agentry. Personal spike, not a maintained product.