AI coding agents, with the brief attached.

A software task rarely starts with code alone. Ghost can turn the useful context from your work into a focused coding request, delegate it to a supported agent, and bring the result back for review.

Request access See how it works

Local repositories and managed apps · Reviewable work · Part of Ghost

Coding handoffIllustrative workflow

Fix the issue behind the task.

Brief: Use the rollout note to explain the expected behavior.
Scope: The relevant project and the failing path.
Evidence: Report the changed files, checks run and remaining limitations.

Illustrative request. No repository is connected by this page.

Give the coding task a brief it can follow.

A bounded request, the right workspace, and a checked result. Ghost can connect a coding workflow to the same notes and next steps as the rest of your work.

Name the change and its boundary.

Bring the issue, relevant note, and acceptance checks into the request. Make clear which project is in scope and what must stay unchanged.

Coding brief · Atlas

Change: Add a filter to the readiness dashboard
Boundary: Preserve existing records and unrelated changes
Acceptance: Filter works and the original view still loads

Choose the workspace that owns the work.

Local repository tasks can use the configured local coding integration. Managed web-app work follows the app-scoped coding path so the result remains attached to the app.

Execution path

Local project: Configured local coding integration
Managed app: App-scoped implementation workflow
Experiment: A bounded sandbox task

The chosen tool must be available and authorized.

Review the change and what was tested.

A coding result should identify the actual changes, test outcomes, and anything left unresolved. A tool finishing is not proof that every acceptance check passed.

Result review

Checking the change

Reviewing the code changes…Reviewed the code changesFilter logic and its visible control

Checking test and runtime behavior…Checked test and runtime behaviorRelevant acceptance checks

Recording remaining limitations…Recorded remaining limitationsAny unverified behavior stated explicitly

Preserve the boundary

Unrelated user changes stay untouched.

Bring the result back to the work.

Keep the implementation summary with the task. If the result is a managed app that should go live, publication and live-route verification are separate steps.

Handoff

Note: Implementation summary and limitations
To-do: Remaining acceptance or review work
Publication: Only when explicitly requested

Follow the publishing lifecycle.

Illustrative delegation. Available coding tools depend on setup. Local repository work and managed-app implementation are distinct execution paths, not universal provider compatibility.

Coding sessions, connected to the work around them.

AI coding agents can inspect a project, make software changes and check the result. Ghost coordinates supported coding workflows: Codex for local repository tasks and OpenCode for durable managed apps. Ghost carries the brief and follows the task state; it is not a replacement model or a promise to run every coding tool.

Give the agent the reason for the change.

A request such as “fix the rollout view” needs more than a filename. The expected behavior, the relevant decision and the conditions for calling it done make a better brief.

Use a source-linked note to keep the longer explanation and a to-do to hold the actionable next step. Ask Ghost to bring the relevant context into the coding request instead of forwarding unrelated history.

Code review, debugging and implementation are different tasks. State whether you want an explanation, a review, or changes to the project so the coding session starts with the right scope.

Purpose: What should be different for the user?
Scope: Which project and behavior are in bounds?
Constraints: What must stay unchanged?
Checks: What evidence will make the result reviewable?

Use Codex for a local repository.

Ghost can delegate coding, debugging, architecture and repository work to Codex CLI through the Mac desktop app. The request names a working directory and runs in a workspace-write sandbox.

A new task starts asynchronously. Ghost receives a status reference, can inspect whether the task is running, completed or failed, and can continue a completed session with the returned session identity.

The local route requires the desktop app and configured Codex access. A session starting is not proof that the change is finished. Runtime limits, missing dependencies and unsuccessful checks should remain visible in the handoff.

Local projectIllustrative workflow

A scoped repository task.

Agent: Codex through the Ghost desktop app.
Workspace: The chosen local project.
Request: Investigate the failing behavior; make the requested change and check it.
Handoff: Changes, verification and any blocker.

Provider access and local setup are required.

Keep durable apps in their own coding session.

A managed app has a different lifecycle from a local repository or a temporary script. Ghost uses OpenCode through the app-specific coding workflow, tied to the exact app and its workspace.

The same app session can handle an implementation request, inspect progress, accept a focused correction or be cancelled. Its scope includes application code, dependencies, builds and the setup needed to run the app.

Keep one-off experiments in Playground. For a durable app, Publishing handles the next stages after coding readiness: verify the app, create the requested route and record the confirmed publication.

App identity: One selected managed app and its bound workspace.
Coding: Source, dependencies, build and runtime setup.
Review: Inspect progress and the completed handoff; correct what is missing.
Publication: An explicit next stage, not an automatic effect of editing code.

A result should say what was checked.

Useful coding work ends with evidence you can review: the changed behavior, relevant files, tests or checks that actually ran, and anything still unresolved. It should not claim that a passing command proves every path works.

Ghost can use the task’s context to explain the result in the language of the original request. A browser check may be appropriate for a website change; a document or dataset may need a different verification step.

Review consequential changes before relying on them. Coding agents can make mistakes, and a clear brief or sandbox does not guarantee correct or risk-free software.

Review handoffIllustrative workflow

Return to the original request.

Changed: Explain the behavior that was updated.
Checked: Name the tests and observations actually completed.
Still open: State missing coverage, setup limits or remaining work.

An example handoff format, not a claim that a test ran here.

Product details

Coding agents, at a glance.

Supported work, useful outputs, and what to check before you start.

Brief: A scoped implementation request, the target repository or managed app, and the context needed to work on it.
Execution: Local coding and managed-app coding use different tools and environments. The required agent, workspace, and credentials must be available.
Review: Inspect changes and checks before treating the work as complete. A coding result does not authorize a commit, push, or public release beyond the requested scope.

One assistant. Connected work.

Ghost is a personal AI assistant for Mac. Its meetings, notes, tasks and execution tools are capabilities of the same product—not separate assistants you have to brief from scratch.

A meeting decision can become a note and a to-do. Ghost can turn that brief into a local coding task or a managed app session, then connect the reviewed result to the same work. Browser and Sandbox capabilities support the steps that need them.

Notes
Keep the decision and implementation brief.
To-dos
Track the change and its next review.
Sandboxes
Choose the right execution environment.
Browser
Inspect a supported website workflow.
Publishing
Take a verified managed app through delivery.

Questions about coding agents in Ghost.

Which AI coding agents does Ghost use?

The inspected workflows support Codex CLI for local repository tasks and OpenCode for durable managed apps. These are distinct routes with different setup and lifecycle requirements, not a universal compatibility promise.

Is Ghost itself a coding model?

No. Ghost is the assistant coordinating the request and its surrounding work. Supported coding tools perform the delegated software task. Their availability and provider configuration affect what can run.

Can I resume a coding task?

For local Codex work, Ghost can inspect the status reference and continue a completed session using its returned session identity. Managed app work can continue through the same app-bound OpenCode session. Missing or expired state may limit continuation.

Will every file edit ask me for approval?

No. The local Codex route runs within a workspace-write sandbox and does not request approval for each edit. Define the project and task carefully, and review the changes. Managed apps use their own app-scoped workflow.

Can coding agents automatically publish my app?

Coding readiness and publication are separate. A managed app needs verification, a requested exposure step and a recorded publication. A finished coding session does not by itself mean a public URL is live.

Is coding included for free?

Ghost is in private beta. The current offer is described on the homepage, and provider access or local tooling may require separate setup. This page does not promise a free or unlimited coding plan.

Start with the brief. Return with the evidence.

Bring software work into the same assistant that knows the task, its sources and the next step. Ghost is in private beta for macOS.

Request access