See the handoff in 38 seconds.
Start in Codex, choose Collaborative, and follow a Postgres-backed team invite feature from request to reviewed result. DeepSeek builds, Mosaic runs checks and routes corrections, and Codex reviews the passing work.
- DeepSeek builds
- The local model writes code for a focused assignment and returns its work.
- Mosaic coordinates
- It routes assignments and feedback, runs checks, and records the work.
- Codex reviews
- The frontier agent independently reviews passing work and can request a correction.
Read the walkthrough
- Start in Codex with “Add Postgres-backed team invites,” then choose Collaborative.
- After plan approval, Mosaic sends a focused assignment to DeepSeek: implement the database migration, invite API, and tests. Mosaic's terminal shows the work and recorded handoffs.
- Mosaic runs checks, then sends the passing code and evidence to Codex for review.
- Codex catches an edge case: expired invitations must be rejected. Mosaic routes the correction to DeepSeek, which adds the expiry guard and a regression test.
- Mosaic repeats checks and review. Accepted changes are integrated, and the reviewed feature returns to the original Codex chat.
This animation uses recreated Codex screens and sample task data; it does not run a live job. Local inference runs on your hardware; a Codex review can involve cloud processing.
Give the goal once.
Put local AI to work.
Running a local model gives you AI on hardware you control. Getting it to work alongside a frontier coding agent can still mean copying prompts, rebuilding context, explaining the plan again, and coordinating the handoffs yourself.
Mosaic is a local-first orchestrator being built to connect any frontier coding agent with any local AI model. It brings the two together around one goal, coordinating planning, scoped tasks, implementation, checks, review, and integration.
The focus is making local AI useful for substantial work, with frontier capabilities available for guidance, collaboration, and review. The long-term goal is to let you choose both sides of that connection while Mosaic carries the workflow between them.
How a coding job moves through Mosaic
The workflow makes the handoffs explicit, from the first brief to a result that has actually been checked.
- 01
Agree on the outcome
Start with a concrete goal and decide what a successful result looks like. Mosaic keeps the accepted plan, the repository, the files that may change, the checks, and the limits together.
- 02
Give each model a defined job
Choose how the local model and frontier coding agent work together. The local model can plan stages and carry out implementation, while the frontier agent provides guidance, contributes to the build, or reviews the result according to the workflow.
- 03
Check the actual work
Run the agreed checks against the candidate. A model saying it finished is only a report; the changed files and check results are the evidence. In the review workflow, passing checks come before automatic frontier review.
- 04
Review, revise, and bring it together
Review the candidate against the goal. A result can be accepted, sent back for a focused correction, or left with a clear blocker. Accepted code goes through integration checks, with the task history retained.
Four ways to work
These workflows describe the roles of the local model and frontier coding agent. Today they are implemented with DeepSeek and Codex; extending them to other agents and models is the direction we are building toward.
Collaborative
Frontier agent + local modelThe frontier coding agent works with you and delegates focused assignments to the local model. Both can contribute to the build, with candidates coming back for review before integration.
Hands-on building with local AI as a working partner.
Local-only
Local planning and executionThe local model plans and carries out work within the approved scope. Checks assess the result, with no frontier agent stepping in to implement or repair it.
Work you want your local model to take on independently.
Frontier-only
Frontier coding agent executionThe frontier coding agent handles implementation and review through the same task, scope, and evidence system. The local model does not receive planning or implementation assignments.
A frontier-agent workflow with explicit scope and a durable task record.
Overnight review
Local model builds. Frontier agent reviews.The local model plans and implements staged work. The coordinator runs checks, and bounded frontier reviews follow passing stages. In the current implementation, the coordinator can continue independently after a verified start.
Give local AI substantial work, then inspect the checked and reviewed result.
The selected mode stays attached to the goal. A change of workflow needs an explicit transition or a separate goal; it does not erase earlier attempts or spending.
Built around evidence
Generating code is one part of the job. Mosaic also tracks the conditions under which that code should be accepted.
- Scope you can inspect
- The agreed repository, permitted files, and checks travel with the task. A model response does not grant itself permission to expand the work.
- Separate candidates
- Implementation work can be prepared in isolated Git worktrees. Review and integration are separate steps, so a finished candidate can be inspected before it enters the combined result.
- Checks before automatic review
- In the local-build, frontier-review workflow, automated checks filter the work before a frontier review call. The aim is to let the local model iterate and reserve frontier attention for candidates that already meet the mechanical requirements.
- A history you can follow
- Saved tasks, model handoffs, check results, review feedback, and available artifacts help explain how a result was reached. The local observer provides a view into that history.
- Limits that remain attached
- Deadlines, attempts, model requests, and review allowances bound a job. A failure or reconnect preserves what has already happened rather than starting the accounting over.
Checks and model review provide evidence against the agreed requirements. Their coverage determines what has been verified.
The setup behind Mosaic
I'm building Mosaic with local compute I own: 2 DGX Sparks running one distributed DeepSeek service, connected to a coding coordinator on my Mac.
This is the current implementation: DeepSeek supplies local inference and Codex supplies the frontier coding agent. The broader architecture is being built around those two roles, so support can extend to other local models and frontier agents.
Where Mosaic is today
An actively developed local-first coding orchestrator. Broader agent and model compatibility is the next direction.
Current coding core
Codex + DeepSeek is the current integration. It supports four workflow modes, scoped coding tasks, isolated native candidates, checks, review and integration, saved task history, and a local observer. Overnight review has its own coordinator for independently running staged work.
What I'm working toward
Connect any frontier coding agent with any local AI model through the same orchestration layer. The aim is to make your choice of agent, local model, and inference setup replaceable while preserving the shared workflow. Broader compatibility is in development; general research workflows remain outside the current coding-core release.
Mosaic is still evolving. This page describes the project and its current direction; a public release date and self-serve download are not announced here.
A few practical questions
Which agents and models does Mosaic support?
Today, Mosaic works with Codex and DeepSeek. We are building toward support for any frontier coding agent and any local AI model. That broader compatibility is the product direction; support for every agent and model is not available yet.
Who is Mosaic for?
Developers and technical builders who want to put local AI to work on substantial projects. Mosaic is being built to connect the local model you choose with the frontier coding agent you choose, so local inference can participate in a coordinated build.
Is Mosaic a model?
Mosaic is the orchestrator connecting a local AI model and a frontier coding agent. It manages the handoffs, shared task state, scope, checks, and record of their work. The models contribute the intelligence; Mosaic coordinates how they work toward the same goal.
Does everything stay local?
Local-model inference runs on your own hardware. Workflows involving a cloud-based frontier coding agent can also include cloud processing. Local-first means the local model has a central role; which model receives a task depends on the workflow and approved scope.
Do you need two DGX Sparks?
The two Sparks describe my current development setup. They run one distributed DeepSeek service, rather than a separate agent on each machine. Mosaic connects to an existing model service; model installation and hardware management are separate from the coding coordinator.
Can every workflow keep going after I close the chat?
In the current Codex-based implementation, overnight review has an independent coordinator after a verified start. Native agent work and supervision in the other workflows depend on an active host chat. Background execution for additional agents will need its own integration and validation.
What happens when a task gets stuck?
The task retains its earlier evidence, consumed attempts, and deadline. Depending on the workflow and remaining allowance, it can request a focused correction, ask for a decision, or stop with a blocker. Resuming work does not silently reset its limits.
Can I try it?
Mosaic is in active development. This page is the current product overview, and there is no public self-serve signup here yet. Get in touch if you want to discuss the project, see a walkthrough, or follow its progress.