u/Defiant-Bill6977

I am from India, I am planning to start an agency (operating alone) and using Wise for handling all the payments.

The catch is, my work is commission based, so I have to receive full amount (could be up to $5k-10k invoices), and pay forward the most of it while keeping 10-20% of it.

I do not have a registered business, but my AI research concludes I need to register a US LLC to avoid conversion taxes (if I register as an Indian business).

I was also thinking of bypassing it by creating the wise business account as a freelancer (as I wont need business details there), but I believe in that case I wouldn't be able to hold money in USD in Wise, and it will directly be sent to my personal account? or am I wrong?

I hope my problem is clear so far, please suggest any workarounds possible or any solution to this. I am considering registering as a business after a few payments I receive to bear the cost of it.

PS: I have came up with two options, either I ask the sender to send us payments separately, where I don't like the idea of revealing my commission to the client. 2nd option is to directly ask him to send the next person, and I ask my commission from him after he receives it. Here also I don't want him to know how much I charged the client. There are also trust issues and additional inconvenience in both cases.

Any better solutions would really help. TYIA

Background: I'm a Principal Architect working on .NET 8 microservices at scale (~600 locations, 44k articles). I got tired of burning Claude/GPT tokens on tasks that don't need frontier reasoning, so I rebuilt my entire coding workflow around Spec-Driven Development with per-phase model selection.

The core insight is obvious once you see it: different phases need completely different capabilities. A phase that maps files has nothing in common with a phase that writes a formal spec. Running both on Claude Opus is like using a sledgehammer to hang a picture.

---

The 9-phase setup:

sdd-init → DeepSeek V4 Flash (OpenCode Go)

The goal of this phase is simply to build an initial understanding of the project. The agent maps the repository, detects conventions, identifies technologies, and gathers context that will be used throughout the workflow. There is very little reasoning involved at this stage. Speed and context size are far more important than deep analysis, which makes DeepSeek V4 Flash an excellent fit.

sdd-explore → Kimi K2.6 (OpenCode Go)

This is where the agent starts exploring the codebase in depth. It reads existing implementations, follows dependencies, analyzes test suites, and identifies patterns across the repository. Kimi performs particularly well here because it can process large amounts of information efficiently and leverage its agent capabilities to explore different parts of the codebase simultaneously.

sdd-propose → GLM-5.1 (OpenCode Go)

At this stage the objective is not to write code but to think through possible approaches. The agent evaluates alternatives, considers trade-offs, and proposes a direction before any implementation work begins. GLM-5.1 has proven especially strong at this kind of structured reasoning and technical decision-making.

sdd-spec → DeepSeek V4 Pro (High Reasoning)

The specification phase is one of the most important parts of the entire workflow. Every subsequent phase depends on the quality of the specification. If requirements are ambiguous or incomplete here, those problems will propagate into design, implementation, and verification. For that reason, this is one of the few stages where I always prioritize quality over cost.

sdd-design → DeepSeek V4 Pro (Medium Reasoning)

Once the specification is complete, the focus shifts toward technical design. This includes defining components, class structures, responsibilities, interfaces, and architectural boundaries. The hardest decisions should already have been made during the specification phase, so medium reasoning effort is usually sufficient here.

sdd-tasks → DeepSeek V4 Flash (OpenCode Go)

This phase converts the design into a structured execution plan. The objective is to generate a clear sequence of implementation tasks with dependencies in the correct order. Consistency and speed are more valuable than advanced reasoning, making Flash the most efficient choice.

sdd-apply → DeepSeek V4 Pro (High Reasoning)

Most of the actual coding happens during this phase. It is also where the largest percentage of tokens is typically consumed. Small mistakes here can become expensive because they often trigger additional review cycles, debugging sessions, and rework. For that reason, I prefer using the highest-quality coding model available during implementation.

sdd-verify → Qwen3-Coder 480B (OpenRouter)

Verification acts as an independent reviewer. The agent compares the implementation against the specification, runs validation steps, examines generated code, and looks for inconsistencies. Qwen3-Coder has shown particularly strong performance in coding workflows that require reliable tool usage and structured validation, which makes it a very good fit for this phase.

sdd-archive → DeepSeek V4 Flash (OpenCode Go)

The final phase focuses on summarizing the work that was completed and storing useful knowledge for future tasks. The process is mostly mechanical and does not require extensive reasoning. A fast and inexpensive model is therefore the most practical option.

Orchestrator: Claude Sonnet 4.6 (OpenRouter): coordinates gates, not code.

The cost breakdown:

OpenCode Go is $10/month flat and includes GLM-5.1, Kimi K2.6, DS V4 Pro, and DS V4 Flash. That covers 8 of 9 phases with no per-token billing.

The only external spend is Qwen3-Coder 480B on OpenRouter ($0.22/M input, $1.80/M output) for verification, low volume, costs cents per session. Plus a few cents for the Claude orchestrator.

Total: ~$12-15/month regardless of how many features you run.

---

A few things I learned that might save you time:

- Kimi K2.6 doesn't have reasoning tiers (it uses Thinking/Instant modes, not [low/med/high]). Don't waste time looking for the parameter.

- GLM-5.1 is genuinely better than Kimi for reflective phases (propose, spec critique) even though Kimi scores higher on aggregate benchmarks. The Code Arena Elo difference shows up in practice.

- The Qwen3-Coder 480B choice for verify is specifically about tool call accuracy, not raw coding skill. In verification, a failed shell call = a missed bug. That 7-point gap matters more than people realize.

- Flash for init/tasks/archive is not a compromise. Those phases literally don't benefit from more reasoning; you're just burning money.

---

Wrote the full analysis with benchmark citations here: https://medium.com/@guidorusso95/i-chose-a-good-harness-but-did-i-choose-the-right-models-c4f201b4b926

Happy to answer questions about the orchestration layer, the OpenCode Go limits, or why I kept Claude only for the orchestrator.