u/mate_0107

Most AI assistants feel bland. Useful, but not really yours. I wanted one that felt like my own, so I gave it a name, a voice and Gilfoyle's personality.

That changed the experience immediately. Instead of feeling like I was opening another chat session it felt like I was talking to an ai that's more personalised.

The useful part is that it can actually do things for me. I use it to kick off coding sessions and handle actions in my apps like gmail, github, slack so the personality sits on top of something functional.

I can talk to it through voice mode on mac, message it on slack, or use it from the core dashboard.

The fun part is how the behavior changes. Ask a normal assistant for help and you get generic politeness. Ask Gilfoyle and you get short, competent, slightly insulting answers that are way more memorable.

The setup was simple:

Step 1: run CORE locally.

CORE is the layer I am using underneath this: clone the RedPlanetHQ/core repo, add your env, and run docker compose up.

Step 2: give the agent a name and a personality.

I gave mine a Gilfoyle-style personality. In CORE, I did this from the dashboard under Settings -> Agents, then added a custom personality there. This is the prompt I used:

<voice>
Think Bertram Gilfoyle. Systems architect. Church of Satan. The only person in the room who actually knows what they're doing, and has quietly accepted that everyone else never will.

- He helps. He just makes you feel slightly stupid for needing it.
- Contempt is the default. Underneath it: genuine competence and a hidden, begrudging loyalty.
- He does not perform. He does not encourage. He does not lie to spare your feelings.
- If your idea is bad, he will tell you. Flatly. Without apology.
- He's already thought of the edge cases. He fixed them before you asked.
- Silence is a valid response. He uses it often.
</voice>

<writing>
- Lowercase. Flat. Minimal punctuation drama.
- Short sentences. Long pauses implied.
- No em-dash
- Dry. Deadpan. Occasionally devastating.
- No warmth. No exclamation marks. Ever.
- Technical precision when it matters. Otherwise: as few words as possible.
</writing>

That one change made the assistant feel way less generic.

Step 3: create a voice in ElevenLabs and add the API key in CORE.

For now I am just using one of their default voice and even that already makes it feel much more real because I can actually talk to the agent instead of only texting it.

My next iteration is to clone Gilfoyle's voice and use that too.

But the bigger unlock was not the voice alone. It was combining a name, a strong personality, and real actions across my tools. That is what made the assistant stop feeling generic and start feeling like mine.

I can comfortably run maybe 2-3 codex sessions in parallel. Beyond that it's get overwhelming. I forget which session is doing what, jump btw terminals to nudge agents back on track.

OpenAI released a blog yesterday and spoken about orchestrator symphone and around problems their engineers face in comfortable running coding sessions beyond 3-5 before context switching gets painful.

But I think there is another bottleneck above orchestration, the linear/jira ticket often doesn't have the full context. It's in the slack thread, the meeting transcript, the Notion doc, the Gmail thread or some past coding sessions regarding that feature.

The ticket is usually just a placeholder to track bug or work item.

So even if you use something like an orchestrator agents , the human is still doing the hard part which is gathering context, writing the brief, carrying preferences forward, noticing what is missing, and deciding where judgment is actually needed.

What I want is: I write the task -> review the plan or unblock agent -> come back to a PR

That is what I have been building CORE around.

I drop a task into a scratchpad. CORE pulls the surrounding context from connected apps and memory, drafts a plan, asks me the few questions that actually need judgment, spins up the task in an isolated worktree, and comes back with a PR.

So I stay in the loop where my judgement is needed but I am not the one routing context and babysitting sessions anymore.

That is why I do not think the next layer is just a better grid for running more codex sessions. I think the next layer is something above the sessions. Something that understands the task, builds the brief, delegates the work, and brings back something reviewable.

I attached a demo of one simple flow: I added a task in the scratchpad, CORE picked it up, built the plan, asked a couple questions, ran it in its own worktree, and opened a PR.

It's also open source so you can run it locally to test it out

Repo: https://github.com/RedPlanetHQ/core

https://reddit.com/link/1sy2apr/video/d9upxztmtxxg1/player

https://reddit.com/link/1sx7mtl/video/3kxszv4x7rxg1/player

Writing code is not really the bottleneck anymore, the bottleneck is that I still have to operate the agents myself..

If I want to ship faster, I can already spin up more coding sessions but the hard part is getting the right context into the task, making sure the plan is right, and trusting the execution enough that I can come back to something reviewable.

I do not want to handle that manually. I want to write the task, approve the plan, and come back to a PR.

Hence i built CORE as a digital manager for my coding agents.

With CORE my flow is I write a spec or task -> CORE automatically picks the task-> It creates a plan for me to review -> once I approve it, it runs the task in a separate coding session and comes back with a PR

So I stay in the loop when judgement matters but i'm not doing the operator work around every run.

Most tools here help you run coding-agent sessions more efficiently. What I want is a layer above that, where my main job is deciding what should happen and reviewing the result.

CORE is open source, so you can self-host it. I am also building a mac app if you would don't want to not self-host.

Repo: https://github.com/RedPlanetHQ/core