Open source · MIT

Codex, inside ChatGPT.

Codexify is a local Rust MCP bridge that gives ChatGPT Codex-style tools on your machine while letting you use the full ChatGPT web model lineup — including Sol 5.6 Pro, which is not available in Codex.

Install Codexify See how it works

All ChatGPT web models Sol 5.6 Pro included macOS, Linux, Windows Codex quota is not used. Unlimited on Plus/Pro plans!

‹

ChatGPT Chat

···

@Codexify Fix this bug!

Worked for 14m 25s

I inspected the failing parser test, patched the EOF edge case, re-ran the validation suite, and called show_diff so you can review the exact changes.

get_agent_briefLoaded project instructions and connector context

done

exec_commandRan cargo test parser

done

apply_patchUpdated src/parser.rs

patched

show_diffRendered the current uncommitted diff

ready

3 files changedsrc/parser.rs +22 −4

@@ −118,3 +118,4 @@ fn parse(input: &str) {
118118 if input.is_empty() {
119-    return Ok(None);
119+    return Err(ParseError::UnexpectedEof);
120120 }
121+assert_eq!(parse(""), Err(ParseError::UnexpectedEof));

All tests are green

cargo fmt --all -- --check
cargo test parser — 14 passed
git diff --check

curl -q -fsSL https://codexify.dev/install.sh | sh

Then run codexify quickstart and follow the guided connector setup.

powershell -ExecutionPolicy ByPass -c "irm https://codexify.dev/install.ps1 | iex"

Then run codexify quickstart and follow the guided connector setup.

Models

Full ChatGPT web lineup

Flagship

Includes Sol 5.6 Pro

Tunnel

Official OpenAI runtime

Scope

Local-first projects

The local tool layer

Give ChatGPT a real development environment.

Codexify implements Codex-compatible tool contracts while keeping execution anchored to a project on your machine, without giving up ChatGPT Web's broader model selection.

Use ChatGPT's best models

Stay in ChatGPT Web and pair Codexify with the full available model lineup, including Sol 5.6 Pro.

Files and patches

Read, write, search, glob, and apply structured patches inside the active project root.

Shell sessions

Run commands, keep interactive exec sessions alive, stream input, and bound model-visible output.

git

Git-native workflow

Status, diff, log, commit, push, plus project-scoped diff checkpoints and an MCP App diff view.

↕

Attachment bridge

Bring ChatGPT attachments into the active project and return generated project files as downloadable resources.

MCP

Aggregate MCP servers

Connect local stdio and remote Streamable HTTP MCP servers through a ranked discovery, schema, and call surface.

Skills and instructions

Load project instructions and skills from Codex, Agent Plugin, and supported Claude Code plugin layouts.

Multi-project mode

Bind each ChatGPT conversation to one project, with optional managed worktrees for concurrent isolated chats.

Verified self-update

Standard installations can update in place with release verification, rollback protection, and service restart.

Native background service

systemd, launchd, and Windows Task Scheduler support unattended per-user operation after setup.

How it works

One secure bridge between conversation and code.

ChatGPT calls the connector with whichever ChatGPT Web model you choose; Codexify resolves those calls against the project and tools you intentionally expose.

Cloud

ChatGPT

Your conversation, plans, files, and model-side tool calls.

connectorattachmentsresources

→

Loopback

Codexify

Rust MCP bridge, project binding, tool registry, output policy, state, and supervision.

127.0.0.1bearer tokenrmcp

→

Your machine

Projects + tools

Filesystem, shell, git, skills, managed worktrees, and optional upstream MCP servers.

gitshellMCPskills

Install the native binary

Use the checksummed installer for macOS/Linux or Windows. Standard installs register the per-user background service.

Run `codexify quickstart`

Choose the project scope, create the OpenAI Secure MCP Tunnel, and write the matching Codexify configuration.

Connect from ChatGPT

Add the developer-mode connector using the exact values printed by quickstart, then work against your local project.

Security model

Local by default. Explicit at every boundary.

The native tunnel path is designed so Codexify does not need to expose a general-purpose inbound URL to the internet.

The bridge stays on loopback.

In native-tunnel mode Codexify listens on 127.0.0.1, authenticates its MCP endpoint with a random per-process bearer token, and supervises OpenAI's official runtime-only tunnel client. The tunnel client makes outbound HTTPS requests to OpenAI.

Verified tunnel runtimeThe pinned official tunnel client archive is checked against a SHA-256 embedded in the build.

Project-scoped accessWork is constrained to the configured project root or selected project in multi-project mode.

Optional conversation gateAn advanced per-conversation authorization token can be required before ordinary tool calls are accepted.

Bounded model-visible outputConnector-wide output policy limits tool payloads and redacts secrets/checksums from trace previews.

Keep the model in ChatGPT. Put the tools on your machine.

Codexify is open source, MIT licensed, built in Rust, and designed to keep you inside ChatGPT instead of forcing you into a narrower Codex-only model menu.

View on GitHub Read the wiki Latest release