Your own
developer.designer.planner.server admin.video editor.tech company.

Mark, Pablo, Steve, Bill, and Zach. Each one a pro at one thing, all of them in the same conversation on your phone. You ask, and they don't stop until it's live.

English and Hebrew. Phone and browser. An isolated environment of your own.

Pablo, Designer
Opera, Planner
Steve, App manager
Bill, Infrastructure manager
Zach, Video editor
Mark, Developer
Task "Fix the sign-up screen and ship a new version to both stores"
What happens when you hand over a task

One sentence goes in. A product comes out.

No form to fill in, no screen to learn. You ask in plain words, and the work runs in front of you until there's something to show.

Waiting for a request
Request Spec Build Store

Your browser asked for less motion, so the demo is waiting for you.

A live demo. Watch it run, or step in and type a request of your own.

This is a demo. It isn't connected to the product, no model is running, and no customer data is involved. Everything the Kringls say here is scripted, except the request you type.

After the code is written

The work ends when it's live.

Code that was written and never shipped helps nobody. So the conversation doesn't end at the code. It ends when a real user sees the change.

  1. 1Mark

    Up to the server

    Over FTP, SSH, or git push, whichever the project already uses. Then it clears the cache and checks that the live page really changed.

  2. 2Mark

    A database with a safety net

    Reading is free, and every write is recorded. If something goes wrong, the rows go back to what they were in one step.

  3. 3Steve

    A version for both stores

    One queue for Google Play and the App Store, inside your own store account. Steve follows the review and posts updates in the conversation.

  4. 4Bill

    A server someone looks after

    Bill works on your server, or on a managed one you order from the screen, with its own address, an SSL certificate, and a nightly backup.

The team

It's not an agent. It's Mark.It's Pablo.It's Opera.It's Steve.It's Bill.It's Zach.

An agent is something you operate. A Kringl is someone you call by name, like anyone on your team: each one has one job they do well, and they're all in the same conversation.

Mark

Mark

Developer

Writes the code and keeps the whole project in his head. He's the one you talk to.

Pablo

Pablo

Designer

Comes back with three directions as screenshots, then builds the one you pick all the way.

Opera

Opera

Planner

A fuzzy request goes in. One clear page comes out.

Steve

Steve

App manager

Versions for both stores, replies to Apple's reviewers, and a close watch until the release reaches users.

Bill

Bill

Infrastructure manager

The server, the database, and the backups. Slowness, load, or a full disk ends up with him.

Zach

Zach

Video editor

Promos and product videos, filmed inside the app itself.

Two more join when needed: Elon builds a business plan and pricing, and Kim researches the market and the competition. The names don't change, and what they learned about your project stays with them.

Your people, in the same conversation

Everyone in one room.

A product manager, a designer, and a developer join the same conversation, see the same work, and talk about it instead of passing files around. Whoever joins later reads what happened and doesn't have to start from zero.

For software houses

Every client. One team.

A software house runs several clients at once. Every project sits in its own place, every person sees only what they're allowed to, and how much can be spent is your call.

  • A project per clientEach client's conversations, versions, and servers sit together, on desktop and on the phone.
  • Access per person and repositoryWhoever works on one client doesn't see another client's code.
  • Spending capsMonthly, daily, and per task. How high each one goes is up to you.
  • A person approves the mergeWhoever wants to see every change before it goes in gets a review board.

Wizzo, a software house working since 2008, runs all of its client work on Kringl.

Connections

Works with what you already have.

The team connects to the tools you already have open. An error in Sentry or an issue in GitHub opens a conversation by itself, and nobody has to copy it over.

  • GitHub
  • GitLab
  • Bitbucket
  • Slack
  • Monday
  • Jira
  • Sentry
  • Gmail
  • MCP servers
  • Morning
  • iCount
  • Your browser
  1. Sentry

    A new error

    TypeError on the sign-up page, 14 users ran into it

  2. Conversation opened

    Mark reads it

    Finds the line, fixes it, and writes a test that catches it next time

  3. Fixed

    Live on the server

    The fix is up, and a three-line summary is waiting for you in the conversation

Security

The keys stay with you.

A software house doesn't hand over a client's code and server keys without knowing where they sit. So here's where.

An isolated environment per organization

Every organization runs as a separate operating system user, inside a fence. Not just a permission on a screen.

A vault, not a chat

Passwords and keys never pass through the conversation. The team asks for a value by name, you enter it in the vault, and it's never written in any message.

Two-step sign-in

A code from an authenticator app, devices you know, and cutting a device off in one tap.

Starting from zero

No code yet? Start with a meeting.

Opera, Mark, Steve, and Bill sit down with you for a kickoff and ask about the idea, the site, the app, and the server. At the end you press "Start", and the project opens with a repository of its own.

  • A preview from day oneAn address you can send to a client, before there's even a server.
  • A managed server when you're readyPress "Set up a server" on the project card, and Bill looks after it from that moment.
  • Your own domainOne record at your domain provider, a click on "Connect", and the site moves to your address with an SSL certificate.
Market

Whoever's missing waits in the market.

More Kringls wait in the market, and you add them to the team when you need them. Didn't find what you were looking for? Build a Kringl of your own from one sentence, and you can submit it to the market.

MonaDesigner ReshiThe brander HarveyFor legal questions A Kringl of your own, from one sentence
To the market
Routines

Said once. Runs every morning.

Something you say today becomes standing work. It runs by itself every morning, and you only hear about it when there's something to say.

"Every morning at eight, check the site is up, fix the small errors, and send me a line."
What ran this morning, without anyone asking
For people who read code

Under the hood, it's ordinary code.

The Kringls work in your repository like any developer on the team. This is what one conversation leaves in it:

  • Real code

    In the project's own languages and libraries, with no closed layer in between.

  • Tests

    Runs them, fails, fixes, and runs them again before saying it's done.

  • Git

    A branch per conversation and a commit you can read. Every change can be rolled back, and whoever wants to approves it before the merge.

$git diff --stat main
src/BookingButton.vue | 22 ++++++
src/pages/Home.vue | 3 ++-
$npm test
✕ opens the booking form
Tests: 1 failed, 37 passed, 38 total
$npm test
Tests: 38 passed, 38 total
$git log --oneline -1
e41c9a2 [CHAT-212] Book a table button
$gh pr merge 212 --merge
✓ Merged pull request #212
$

And what you already have comes with you

Your own model

The work runs on your own Claude, Codex, or Cursor account. Kringl is the team and the road to the server, not a replacement for the model.

  • Claude
  • Codex
  • Cursor

Your setup

One command on your computer brings your instructions, skills, and MCP servers into Kringl. Your secrets stay with you: only their names come over.

$ npx kringl-migrate
Reads the setup from:
  • Claude Code
  • Codex
  • Cursor
  • Copilot
  • Gemini CLI
  • Windsurf
  • Cline
  • Roo Code
  • OpenCode
Phone, browser, and store

The same workshop, on every screen.

Start a task on your phone on the way in, then open it in the browser on a big screen. Same conversation, same history. The app is already on Google Play.

On the phone
In the browser
Start on your own

Open your workshop.

Sign up, connect an existing repository or start from zero, and the first task is already with the team. The first 14 days are free.

  • An account with Claude, Codex, or Cursor
  • A repository on GitHub, GitLab, or Bitbucket, or nothing yet
  • A phone or a browser
Open your workshop
Software house

A software house? Let's talk.

Leave your details, and we'll get back to you to talk about your clients, your team, and your servers.

Your details stay with us, are used only to get back to you, and can be deleted whenever you ask.

Got it. We'll get back to you.
Questions

What everyone asks.

What is Kringl AI?

Kringl AI is a software development team by Wizzo that you talk to in a chat, in English or Hebrew, from your computer or your phone. The team writes the code, deploys it to your server, manages the database and builds websites and apps. Kringl is not Kringle AI and not Kling AI.

I'm not a developer. Is this for me?

Yes. You ask in plain English, and all you need to know is what should happen. If you're not sure how to put it, Opera asks the questions, and one clear page comes out of your answers.

What happens when something goes wrong?

Mark checks his own work and fixes it before he says he's done. Every code change goes through Git and can be rolled back, and every database write is recorded and can be undone.

Does it replace Claude or Cursor?

No. Kringl runs on them. Connect your own Claude, Codex, or Cursor account, and Kringl adds the team and the road to the server and the stores.

Does my code stay mine?

Yes. The code lives in your repository, in your account, and you can take it and work on it somewhere else any day. No lock-in, no closed format.

Does it work on an existing product, or only from scratch?

Both. Connect an existing repository, and the team learns how it's built and keeps working inside the code you already have. No code yet? A kickoff meeting opens a new project.

How long does it take?

A small fix comes back in minutes. A new screen or a whole feature takes hours, not weeks. Progress is visible the whole time, so you know where things stand without asking.

What does it cost?

The first 14 days are free. After that you pay per seat, meaning per person on your team, not per token: the model runs on your own account. A managed server, if you need one, is billed separately every month.

Which technologies does it work with?

The common languages and frameworks for websites, servers, and apps: JavaScript and TypeScript, PHP, Python, React and Vue, databases, and mobile apps for both stores. An existing product stays on its own stack.

The team is ready

All that's missing is your idea.