How it works

Five stages, measured and marked.

The same sequence a craftsman follows — assess, prepare, build, test, finish. Each stage done before the next begins. That discipline is why thirty days is enough.

The Dandori method

One repeatable path, every engagement.

The same five stages run on every workflow we take on — a simple, repeatable delivery method, with a craftsman's discipline underneath.

Assess

Find the one workflow where a prepared agent earns its place fastest.

→

Prepare

Map dependencies, connect systems of record, write the rules.

→

Build

The governed agent takes shape around the prepared workflow.

→

Prove

It runs on real work, measured against written success criteria.

→

Handoff

The agent, rules, and everything it learned — owned by you.

Beneath the method is the craft: 段取り — preparation is eight-tenths of the work. The five stages are how that principle runs on your operation.

The craft beneath the method

Four cuts. Every agent, every time.

Under the five delivery stages runs an older discipline. A master doesn't improvise the important joints — they follow a sequence proven by repetition, whatever they're building. Ours is four cuts, and no agent we prepare skips one.

一

Understand the grain

Before anything is automated, we learn how the work actually flows — the real steps, the exceptions, the judgment calls hiding inside "it depends." You can't prepare a workflow you don't truly understand, and most AI fails right here, at the cut nobody made.

二

Mark the lines

We write down the rules in plain language: what the agent decides alone, what it must escalate, and what it may never do. The boundaries are drawn before the build — so autonomy is safe by design, not by hope.

三

Fit the joint

We connect the agent to the systems of record you already run and build it against the prepared workflow — reviewed with you as it takes shape. Because the grain was understood and the lines were marked, the joint fits the first time.

四

Prove and hand over

It runs on your real work while you watch. Every correction is captured and kept — as yours. At the end you own a working agent, its rules, and everything it learned. No lock-in, no black box.

The method is why thirty days is enough. The first two cuts — understanding and marking — are the eight-tenths the proverb talks about. Do them properly and the build is the easy fifth.

Thirty days sounds fast for working AI. It's only possible because we spend the first third of it not building at all — but preparing.

A craftsman doesn't measure once and cut ten times. They assess the material, mark every line, lay out the tools in order, and only then make the first cut — which, because of all that preparation, is clean and fast. We build your AI the same way. The five stages below follow the exact sequence of good dandori: understand, prepare, build, prove, finish. Each is complete before the next begins, because a stage rushed is a stage you pay for later.

What follows is not a sales timeline. It's how the work actually goes — and what you get to see and keep at the end of each stage.

見立て · We assess the work — days 1–4

We sit with how your operation actually runs and choose the one workflow where a prepared agent earns its place fastest. No tools yet — just understanding.

段取り · We prepare & sequence — days 5–10

We connect to the tools you already use and write down the rules: what the agent decides on its own, where it checks with you, and what it must never do.

仕込み · We build the agent — days 11–20

The agent takes shape around the prepared workflow — reviewed with you as it's built, never behind a curtain. You see it work before you trust it.

試し · We prove it on real work — days 21–27

It runs alongside your team on live work. We adjust against your corrections until it does the job the way you would. Every correction is kept as yours.

仕上げ · We hand it over, ready — days 28–30

You decide to keep it running. The agent, the rules, and everything it learned are yours to keep — no lock-in, no black box.

Where the magic actually happens

The framework is just tools. The delivery team is the point.

Deploying AI isn't about deploying a framework — frameworks are just tools and processes, and everyone has them now. The real work is done by people who are genuinely expert at their craft: the system integrators who understand how a business actually runs.

Ask anyone who's tried to bolt AI onto a real business where it went wrong, and the answer is almost never the model. It's that nobody in the room truly understood the SAP configuration, the way Salesforce was customized over ten years, the quirks of the data warehouse, the manufacturing process on the floor, the tools the team actually uses. AI can't be given understanding it doesn't have — and generic AI has none of that.

That understanding is what our people bring. Our delivery team are senior system integrators — the specialists who know SAP, Salesforce, databases, data warehouses, and real operational processes deeply, from years of doing the work. They're the ones who can look at your operation and see how it truly fits together. That's how we give the AI the understanding it needs to do its job.

And then the art begins. Understanding gets the AI to the starting line; it doesn't make it reliable. The craft — the part almost no one does well — is molding the AI so it produces the same right result the thousandth time as the first. Repeatable. Reliable. Trustworthy enough to hand real work to. That shaping, that patient tuning against real cases, is what turns a capable model into an agent you can actually depend on.

A framework can be bought by anyone. Deep understanding of your systems, applied by people who've done it for years, cannot. That's the craft — and it's the whole reason our work holds when others' doesn't.

How we deliver so fast

Working AI in days and weeks — not months, not a fortune.

The big consultancies take months and charge seven figures to get AI into production. We don't. Three things let us deliver working AI to operationally complex companies fast — and none of them involves cutting corners.

其の一

Prepared building blocks

We don't build every agent from scratch. We start from proven, prepared components — the connections, the guardrails, the reasoning patterns — and shape them to your workflow. Configured for you, not invented from zero each time.

其の二

A context layer that learns your business fast

Instead of months of discovery, our integration specialists connect to the tools you already run and capture your rules, data, and process quickly — so the agent learns how your operation works in days, not quarters.

其の三

We do the work, not you

This isn't a DIY tool you're left to configure. Our team designs, connects, and delivers the whole thing — so there's no burden on you or a stretched IT person. You bring the workflow; we bring it to life.

And you don't pay a fortune to find out if it works. With the 30-day proof, you see it running on your own work first — then decide. Fast to deliver, fair to buy, and priced to the value of the workflow rather than a multi-year transformation budget.

What makes the thirty days work

Preparation is not the slow part. It's what makes the rest fast.

People assume a shorter timeline means cutting corners. With dandori it's the opposite: the timeline is short because nothing is cut. Most AI projects fail slowly — months of scoping, a build against a target that keeps moving, and a launch nobody quite trusts. They're slow precisely because the preparation was skipped and has to be paid back, painfully, during and after the build.

We front-load it. By the end of the first ten days we know the task cold, the rules are written down, and the systems are connected — so the build has nothing to fight. There's no mid-project discovery that the process was never really agreed, no launch-week surprise about who approves what. The agent goes up against a prepared foundation, which is why thirty days is enough and why what we hand over actually holds.

It also means you're never in the dark. Because each stage produces something you can see — a written map, a set of rules, a working agent, results on real work — you always know where the project stands. There's no black box, no "trust us, it's coming." Preparation done in the open is the whole method.

One job, however many agents it takes

A job done right may take a crew — agents that check each other.

We say we prepare one job, not one agent, because sometimes the job is best done by several agents working together — each with a narrow role, verifying and reviewing before anything is decided. It's the same reason a workshop divides skilled hands instead of trusting one person to do everything flawlessly.

一

Gather

Pulls the data from the right systems.

二

Verify

Checks it's right before it's trusted.

三

Interpret

Decides how the data should be used.

四

Review

Checks the others' work — a second set of eyes.

五

Decide & present

Makes the call, hands you a checked result.

To you it's still one result, one workflow handled end to end. The verification and review happening underneath are exactly what make an agent trustworthy instead of a gamble. More on how this works →

Why understanding comes first

We never automate a mess.

If a task is confused or undecided, automating it just makes the confusion faster. So the first stage is always understanding — we make the work clear before we make it automatic.

Often the assessment alone is worth it: sponsors tell us they understood their own process better after week one than they had in years.

What you get at each stage

After assess — a written map of the chosen workflow
After prepare — the rules and boundaries, in plain language
After build — a working agent you can watch
After prove — results on your real work
After finish — everything handed over, yours to keep

Governance, built in from the start

Fast does not mean unmanaged.

Speed makes people nervous about control, and they're right to be careful. An agent that acts quickly but without boundaries is worse than no agent at all. So governance isn't a phase we add at the end — it's part of the preparation, defined in the same breath as the work itself.

During the prepare stage we write down the agent's authority — what it may decide on its own, what it may only recommend, and what it must escalate to a person. We define the escalation paths, so there's never a question of who steps in when. We make every action observable and logged, so nothing happens that you can't see and reverse. And we keep autonomy segmented and bounded — an agent prepared for quoting cannot wander into your billing system on a whim.

This is what lets an enterprise move fast and sleep at night: the agent is quick because it's prepared, and safe because the same preparation drew the lines it operates inside.

段取り八分 · Preparation decides the outcome

See the five stages run on your work.

Book a workshop and we'll walk your chosen task through all five — so you know exactly what day thirty looks like before you commit.

Book a workshop →