A delivery process for AI-built software

Software delivery wasn’t invented because programmers typed slowly.

Spedito takes a rough idea through planning, coordinated delivery, independent review, and a working demo—with an AI team that gets better every Sprint.

Explore the workflow See the code

Deliver

See your AI team at work.

See what’s moving, blocked, under review, and ready to demo—without asking agents for updates.

01 / 19

The current state of AI software delivery

AI learned to write code. Developers made you learn tmux anyway.

Writing code can now begin with a conversation. Naturally, the industry responded by building another stack of developer tooling around it.

agent-orchestrator — 7 panes

01 Have a perfectly good product idea

02 Open a terminal for some reason

03 Install skills for the AI that already knows how to code

04 Add plugins to manage the skills

05 Memorise slash commands because plain English was too easy

06 Arrange tmux panes until your laptop resembles air traffic control

07 Appoint an AI manager to supervise the AI workers

08 Open another terminal to find out why management has stopped responding

Advanced orchestration

Or go all in: create a Rig, assemble a Convoy, sling some Beads to the Polecats, ask the Witness to patrol them, and let the Refinery manage the merge queue.

Congratulations. You wanted to ship a product and are now mayor of an industrial town. Yes, Gas Town is real

Spedito

Spedito is what AI software delivery looks like when it is designed for the person with the product idea.

It turns the machinery into a product-delivery workflow. Describe what you want. Refine the Backlog. Approve the Sprint. See what is moving or blocked. Review the working Demo.

No terminal. No incantations. No municipal office.

“Can I see it?” should be a button.

One click prepares and launches the reviewed product—no terminal, ports, or setup required.

Prompting

You

Can I see it?

Agent

Of course. Run npm install && npm run dev.

You

Can you run it?

System Port 3000 is already in use.

Agent

I started it on port 3001 instead.

You

Is that the new version?

Agent

Let me check.

A seven-message launch button.

Spedito

T3 · Ready for Demo Ticket details

Tech Lead · reviewed product increment

View weather for an entered location

Search for a place and see its current conditions with a seven-day forecast.

✓ Acceptance checks passed
✓ Tech Lead approved
✓ Integrated against current product
✓ Demo preparation succeeded

Exact reviewed revision 3f8d12a

No terminal. No port archaeology. No ambiguity.

Vague is allowed. Ambiguous isn’t.

A few focused questions turn a rough idea into a prioritised Backlog with clear dependencies.

Prompting

You

Let people share stuff.

Agent

Done. I added public sharing to every result.

You

I meant a private link to one saved result.

Agent

Understood. The private links never expire.

You

They should probably expire.

Agent

That matters. What should happen when they expire?

Implementation is a surprisingly expensive questionnaire. Great vibes, though.

Spedito

The questions happen before implementation. The answers become Tickets, dependencies, and Product knowledge the team can reuse.

Work in parallel, on purpose.

Dependencies decide what can start together, what must wait, and when the next wave can begin.

Prompting

You

Can you split this up and work in parallel?

Agent

Absolutely. I’ll run two agents.

Agent 1 editing App.tsx

Agent 2 editing App.tsx

Merge conflict Both approaches look reasonable.

Two agents. One file. Zero coordination.

Spedito

Plan Sprint 4Share saved results safely

2 waves

Scope3 Tickets

Execution2 parallel

RisksNo flags

Wave 1 · Starts immediately

T12 · Research Choose provider Business Analyst

T13 · Design Design failure states UX Designer

Wave 2 · After prerequisites

T14 · Ticket Build approved experience After T12 and T13

Separate workspaces. Explicit dependencies. Useful parallelism.

“Commit everything” is not a delivery process.

Every change stays tied to its Ticket, its review, and the product result you approve.

Prompting

You

Looks good. Commit everything.

Agent

Done. I committed all changes.

47 files changed

? generated files included

? current branch

You

What changes?

Agent

Let me inspect the commit.

Committed first. Understood later.

Spedito

T14 · Ticket detailsBuild approved experience

In Review

Implementer · 10:42Candidate v2 created7 files · exact revision 3f8d12a

Checks · 10:4442 tests passedDelivery evidence attached

Tech Lead · 10:51Independent review approvedAcceptance criteria and diff reviewed

Integration · 10:54Ready for your demoThe reviewed result was integrated cleanly

Exact candidate3f8d12a

Review preserved

Your decision is whether the product is right—not whether the branch is clean.

Your product is bigger than a context window.

Its memory should compound as structured, verified knowledge—not become another summary of an increasingly enormous chat.

Prompting

Product conversation Day two

48 earlier messages · 2 days

Coding agent

That gives us a clear outcome, three acceptance scenarios, and two pieces of work that can begin in parallel.

You

Perfect. That’s exactly it. Let’s do it.

Context compacting automatically…

The product memory is now a summary of a summary of a chat.

Spedito

Current product Knowledge

Product Sharing and link privacy ✓ Verified · 3 decisions

Architecture Ticket workspace isolation ✓ Verified · 7 sources

Connected knowledge 12 links

Delivery report 4 sprints

First-pass acceptance

✦

Prepared for T19 Current, relevant, and traceable

6 sources

Product knowledge the whole team can browse, verify, and reuse.

“I made significant progress” is not evidence.

Spedito records what actually happened: changes, checks, decisions, permissions, review findings, and exact revisions.

Prompting

Task complete 100% Evidence: immaculate vibes

Agent

Implementation is complete and all tests pass.

You

Which tests?

Agent

Let me verify that.

Verifying previous verification…

All tests passed. Running them is next.

Spedito

10:42 I

Implementer Candidate revision created 7 files changed · Delivery note attached

10:44 ✓

Checks 42 tests passed Build succeeded · No warnings

10:51 TL

Tech Lead Exact candidate approved Acceptance criteria and diff reviewed

10:54 ✓

Integration Merged cleanly against current product Candidate review remains valid

10:56 ▶

Demo Preparation succeeded The exact reviewed revision is ready

Progress is something the Product Owner can inspect.

Your product should survive closing the chat.

Interrupted delivery recovers with its Ticket, Conversation, workspace, decisions, and previous evidence intact.

Prompting

New session No previous context

You

Continue where we left off.

Agent

Certainly. Could you remind me what we were doing?

A fresh start, whether you wanted one or not.

Spedito

In Progress

Build expiring private links

Resuming from the last confirmed checkpoint.

Recovered

✓Ticket workspacePreserved

✓ConversationReady to resume

✓Product decisions4 linked

✓Work logCurrent

Last activity: link expiry checks Resuming work

It continues the work. It does not pretend to start it again.

Safe by default, not by prompt.

Spedito uses Codex’s built-in macOS sandbox. Each product is its own workspace, and each delivery agent is scoped to one isolated Ticket workspace.

Improvised setup

You

Just do whatever you need to get it working.

Agent requests access Your entire Documents folder

DenyAlways allow

Agent requests access Unrestricted network

DenyAlways allow

Agent wants to run git commit -am "everything"

DenyAllow

Somehow, you became the sandbox.

Spedito

⚒

Implementer · Started workPicked up the authorised Ticket

ImplementerAllow additional access?

Needs your input

The agent needs access outside its current Ticket workspace.

Why this is needed Verify the provider’s current documentation and privacy terms.

Exact access Network access · provider documentation only

Current product T14 workspace No credentials

The safe boundary exists before the first prompt is sent.

FAQs

Is Spedito a local app?

Yes. Spedito runs on your Mac and uses your local Codex. Product state, workspaces, Work logs, and Product knowledge stay local. Code changes are made in an ordinary local Git repository, so you can push it to a remote or share it yourself whenever you like. Network access is off unless you explicitly allow it. Built-in remote connection and sync are planned for a later version.

Is Spedito open source?

Yes. The complete app source is available under the Apache 2.0 licence. You can inspect how Spedito works, audit its sandbox and permission boundaries, build it yourself, report issues, or contribute improvements on GitHub.

What does it work with?

For now: Codex on Apple silicon Macs running macOS 14 or later. Spedito uses Codex App Server because it provides a proper two-way integration: structured live activity, diffs, questions, approvals, usage, and resumable sessions—without scraping a terminal. Future Agent Client Protocol (ACP) support is intended to broaden the provider range, but only where a runtime can meet the same sandbox, approval, recovery, and audit guarantees.

How is this different from tools like Spec Kit?

Spec Kit turns “build this” into a nine-command constitutional ceremony:

/speckit.constitution /speckit.specify /speckit.clarify /speckit.plan /speckit.checklist /speckit.tasks /speckit.analyze /speckit.implement /speckit.converge

A very large Spec Kit sequence diagram showing interactions between the developer, CLI, AI agent, file system, and Git across the complete workflow.

When the software-delivery process needs a 146-line sequence diagram and its own scroll bar, the process may have become the product. If this diagram sparks joy, Spedito may feel alarmingly straightforward.

Do I need to know Git or use a terminal?

No. Spedito handles isolated Ticket workspaces, revisions, review candidates, integration, checks, and Demo preparation underneath the product workflow.

Who is on the AI team?

The default team includes a Business Analyst, UX Designer, Tech Lead, and Implementer. You can tune their models, effort, and instructions for each product.

Can agents really work in parallel?

Yes—when the dependency graph says they can. Independent Tickets run in separate workspaces; dependent work waits; integration is coordinated and reviewed.

What happens when I close the app?

The Backlog, decisions, Work logs, Product knowledge, run state, and Ticket workspaces are durable. Interrupted work can resume from the same product context.

Does Spedito replace the Product Owner?

No. AI can ask focused questions, propose scope, identify dependencies, and deliver work. Consequential decisions, access, Sprint scope, and acceptance remain yours.

So when is a Ticket actually Done?

After the exact version of the change has passed its checks, received independent review, integrated cleanly into the current product, produced a working Demo, and been accepted by the Product Owner.

Spedito

AI writes the code. Spedito runs the delivery process.

Download for Apple silicon View source

Apache 2.0 · macOS 14+ · Requires Codex