Our interface to tomorrow.
Some people can walk past a crooked picture. You just can’t leave it like that. You’ve got to set it right so it’s dead level. That’s the kind of builder we need.
We need the person who digs deep into the code and can’t stand an arbitrary limit or three competing ways of doing the same thing. The interface designer who feels physical pain when something is a millimeter off, who asks, “Why does this take ten clicks when it could be two?” The security person who inhaled zero-days as a kid and wants to help shut them down in an era of agentic cyber assault.
If that’s you, help us make Nautilo our interface to tomorrow.
Bring your edgeFind a problem you care about. Show us what you’d make better.
The work ahead
Where can you make a difference?
Pick a field you know, or something you’re determined to learn. Some work is already underway. Come build alongside us.
13 work areas shown
Bring more coding harnesses into Nautilo
Codex and Claude Code already work inside Nautilo. Help connect the tools we don’t support yet, such as OpenCode and Zed. Give them the same place in the conversation: your Genie hands off work, follows its progress, brings back the result, and keeps you in control.
A useful place to start
Pick a tool that’s missing and extend the existing harness integration. Take it through a complete job: connect, choose a workspace, start work, handle an approval, steer, stop, and resume where supported. Make changes easy to review, keep accounts separate, and make failures visible. Build on what’s here rather than creating a second handoff system.
Bring the AI subscriptions you already pay for
Help people connect their ChatGPT, Claude, and other provider subscriptions through supported sign-in and integration paths. Make it clear which account is connected, what it can do, and when work uses a subscription rather than separately billed API access. Nobody should have to guess which bill they’re running up.
A useful place to start
Prove one provider’s supported path from sign-in to useful work, then test expired sessions, renewal, sign-out, and usage exhaustion. Where subscription access belongs inside the provider’s coding harness, integrate that harness. Protect credentials, respect account boundaries, and explain any plan restrictions before someone starts.
Connect the services people actually use
Extend the OpenConnector-based integration path, or put Browser Use through deep, repeatable tests on real websites. We need connections that survive expired sessions, interrupted work, permission changes, and the second attempt.
A useful place to start
Pick one service and one everyday job. Make sign-in, the task itself, and recovery work end to end. Add tests and clear setup instructions. A successful browser run is a starting point, not a blanket claim that a whole website is supported.
Bring Nautilo to more infrastructure
Docker Compose and Railway give us a starting point. Help build deployment drivers for Kubernetes, AWS, GCP, and other environments people already operate. Make installation, updates, and recovery straightforward.
A useful place to start
Take one target through deployment, upgrade, interrupted upgrade, restore, and cleanup. Show what persists, what it costs, and what happens when something fails. Recovery still matters. The next wave is broader deployment choice backed by real operating experience.
Make a great mobile experience even better
Mobile is already a first-class part of Nautilo, on iPhone and Android. Help us keep making it better. We want frontend engineers with a designer’s eye for touch, motion, spacing, keyboards, and the small details that make everyday work feel effortless.
A useful place to start
Choose one flow on a real phone. Find the hesitation, the crowded control, the keyboard hiding the next action. Bring a small before-and-after prototype, then prove it works with accessibility settings, a poor connection, and the app returning from the background.
Sweat the desktop details
Nautilo has a strong design direction. We’re looking for frontend builders who love bringing it to life: rich editors, sharp keyboard navigation, responsive panels, and interfaces that stay clear while several things are happening at once. Work closely with the founder on the details. We’re not looking for a committee to average the personality out of the product.
A useful place to start
Find an interaction that feels almost right. Make it right. Show the difference in a short recording and test it across window sizes, input methods, and light and dark mode.
Make Windows a great place to run Nautilo
The desktop app is built with Electron. We want Windows developers and testers who know where cross-platform promises fall apart: installation, updates, permissions, file paths, audio devices, scaling, and the conventions Windows users expect.
A useful place to start
Run an everyday Nautilo workflow on Windows, record what breaks, and bring a focused fix with a reproducible test. Help us earn confidence in the whole desktop experience, not just a window that opens.
Give Genies a cloud desktop
We’re working on cloud computers that Genies can use, with a human able to see what’s happening and take over. There’s room for a team that understands remote desktops, streaming, isolation, persistent sessions, and keeping someone’s computer available and recoverable.
A useful place to start
Help prove one complete session: start the computer, do useful work, hand control to a person, reconnect after an interruption, and shut it down cleanly. Make the cost and the boundaries clear.
Let agents pay, with permission
Help build responsible payments and agent wallets around established infrastructure, including Stripe’s Agentic Commerce Protocol, Machine Payments Protocol, and Link agent wallets. This is real money. We need people who think about spending authority, duplicate charges, stolen sessions, refunds, and reconciliation before they celebrate a successful checkout.
A useful place to start
Propose one tightly scoped purchase flow using a provider sandbox. Show exactly what the person authorized, how spending is constrained, how credentials stay out of model context, and what happens if the connection dies before the receipt arrives. Never guess whether a payment succeeded and charge again.
Build mini-apps for people and Genies
Make something you’d want to use every day. A great Nautilo mini-app gives a person direct, satisfying controls and gives a Genie precise tools for working on the same thing. Neither side should have to fight the other for control of the document, design, calculation, or plan.
A useful place to start
Bring a small app idea and a working interaction. Show a person editing, a Genie making a change, and the person taking over again. Test saving, undo, interrupted edits, permissions, and reopening the result until it’s dependable.
Find the vulnerabilities before someone else does
We want security researchers who enjoy finding the assumption everyone else walked past. Help test permissions, cross-user data access, tool execution, dependencies, and the ways hostile content can steer an agent toward doing something it shouldn’t. Agent-assisted probing makes careful verification more important, not less.
A useful place to start
Test only systems you own or have explicit permission to assess. Bring the smallest reproducible case and a regression test where possible. Send suspected vulnerabilities privately, never through a public issue or PR. A convincing-looking scanner report is not a substitute for understanding the defect.
Run models on hardware you control
Help explore local inference that makes useful work possible on user-owned hardware. We need people who enjoy measuring what models and runtimes can actually do, including where the experience starts to break down.
A useful place to start
Bring one measured model-and-hardware experiment, with setup steps, representative tasks, and clear limitations. Build on Nautilo’s provider architecture rather than creating a separate agent stack.
Federation: Connect independent Nautilo circles
Help research how independently operated Nautilo servers could collaborate while keeping their own membership, keys, and rules. Start with the people who need to work together and what they should be able to share.
A useful place to start
Bring a concrete collaboration scenario and a small protocol experiment. Explain identity, consent, removal, and what happens when one server disconnects. Help us learn before committing to a large implementation.