Orbit

Orbit's landing page
Task creation
Context and coordination workspace
Photon provider communication
Human-in-the-loop approval
Booking and verification confirmation
Orbit's architecture

Inspiration

You need your dishwasher fixed. Sounds simple, right?

Except now you're calling repair companies, comparing quotes, figuring out who's available Tuesday, filling out booking forms, and following up to make sure someone actually shows up.

Somehow, a five-minute problem has turned into an entire afternoon of playing project manager.

And it's not just repairs. Appointments, deliveries, reservations, and customer service all come with the same endless back-and-forth. Companies have entire operations teams to handle this stuff. We have ourselves.

So we started wondering: what if you could just tell an AI what you need, and it handled everything else? Not just drafting an email or suggesting who to call, but actually coordinating the process and making sure it got done.

Introducing Orbit.

What it does

Orbit is your personal AI operations assistant. You tell it what you want accomplished, and it figures out how to get there.

For example, you can say:

"My dishwasher needs a visit. Tuesday afternoon works. Keep it under $150, and ask me before booking."

Orbit takes it from there through three core systems:

Context Intelligence: Orbit keeps track of what matters: your budget, availability, preferences, and conversations. It remembers where information came from, so it doesn't lose context between interactions.
Adaptive Coordination: Orbit messages providers, checks availability, navigates booking websites, and manages the steps needed to complete your request. If something changes, like a provider raising their price, Orbit can adjust its plan instead of blindly continuing.
Reliability and Verification: This is the part we're especially excited about. Orbit doesn't just assume something worked because an agent said it did. A separate verification agent checks the actual evidence against what you approved.

And importantly, you're still in control. Orbit can handle the annoying back-and-forth, but it asks before making commitments on your behalf.

How we built it

The frontend is built with Next.js, React, TypeScript, and Tailwind CSS. We wanted Orbit to feel less like a developer tool and more like something you'd genuinely use, with a workspace where you can watch tasks progress, review decisions, and see exactly what the agent is doing.

The backend uses Python and FastAPI to manage workflow state and coordinate the different components.

We designed Orbit around a continuous loop: understand the request, build a plan, take action, check the result, and adjust if necessary.

Our core architecture:

Context Layer: Stores structured facts, user constraints, and conversation history with source references.
Orchestration Engine: Breaks objectives into steps, tracks dependencies, and updates plans as new information arrives.
Verification Agent: Independently compares action results against approved terms and supporting evidence.
Approval System: Ties user approval to specific terms, so an outdated quote can't quietly turn into an unauthorized booking.

Sponsor technologies:

Photon: Powers messaging and communication with service providers.
Browser Use: Handles navigation and booking workflows on provider websites.
CREAO: Helps transform natural-language requests into structured workflows.
Sentry: Provides tracing and debugging for workflow execution and failures.
Google Gemini API: Interprets natural-language requests, extracts important constraints like budgets and availability, and helps plan and coordinate workflows.

We also built an offline demo environment so we could test the full interaction flow without depending on every external service being available.

Challenges we ran into

Getting agents to agree on what's happening. A provider's text message, a user's approval, and a booking confirmation might all contain information about the same appointment. Keeping those details consistent across systems turned out to be harder than we expected.

Making approvals actually mean something. What happens if someone approves a $120 appointment, but the provider later changes the price to $180? We had to make sure Orbit wouldn't proceed using outdated permission. That meant tracking exactly what was approved and invalidating approvals when the underlying terms changed.

Knowing when something is really done. Just because a browser agent clicks "Submit" doesn't mean the appointment was booked. We had to separate attempting an action from actually verifying its outcome.

Making autonomy feel trustworthy. We wanted Orbit to work independently, but nobody wants an AI casually spending their money or booking appointments they never approved. Finding that balance between automation and user control shaped a lot of our design decisions.

Accomplishments that we're proud of

Evidence-based verification: We built a separate verification process that checks whether results actually match the user's approved terms.
Context-aware workflows: Orbit tracks where important information comes from and maintains that context throughout a task.
Approval safeguards: Changes to important booking details can invalidate previous approvals instead of allowing the agent to proceed silently.
Adaptive coordination: Our workflow system can respond to new information and revise plans rather than treating every task as a fixed sequence.
An interactive workspace: Users can follow the agent's progress, inspect evidence, review approvals, and understand why a task is or isn't complete.

We're especially proud that we focused on making the AI accountable, not just autonomous.

What we learned

The biggest thing we learned is that making an AI do something is very different from making sure it did something correctly.

It's easy to get excited when an agent sends a message or clicks a button. But real-world tasks are messy. People change their minds, prices change, websites fail, and confirmations don't always arrive.

We learned that reliable agents need structured state, clear permission boundaries, and a way to independently verify what happened.

We also realized that more autonomy isn't always better. Sometimes the smartest thing an AI can do is recognize that it needs more information or ask the user before proceeding.

What's next for Orbit

We're exploring domain-specific context packs so Orbit can understand the different procedures and constraints involved in each type of task.

Longer term, we want Orbit to coordinate multiple people and organizations, negotiate conflicting schedules, and learn from previous workflows while keeping users in control.

Our vision is simple: you shouldn't have to become a project manager every time you need something done.

From "I'll get back to you" to "It's handled."