LazyTax for Codex

Give Codex your tax documents. Get back a return that proves every number.

Inspiration

Tax filing rarely begins with a clean set of facts. Salary appears in Form 16, tax credits appear in Form 26AS, interest appears in AIS, investments sit inside broker reports, and the government prefill may disagree with all of them.

The difficult part is not filling a form. It is finding what is missing, deciding which source to trust, and preserving enough evidence to explain the result later.

A conversational model can simplify this work, but a confident answer is not enough for a financial decision. We wanted to answer a harder question:

Can Codex help prepare a tax return without becoming an unaccountable source of truth?

That became LazyTax.

What LazyTax does

LazyTax is an installable Codex and ChatGPT plugin for Indian individual tax preparation.

A taxpayer can attach authorized documents and speak naturally. Codex inventories the evidence, identifies missing official sources, explains discrepancies, and asks only for facts it cannot safely determine.

LazyTax handles the parts that should not depend on conversational reasoning:

Source lineage for every material amount
Duplicate detection and conflict preservation
Deterministic tax calculations
Explicit approval for material decisions
A structured Tax Proof Pack with an integrity hash
Separate responsibilities for the taxpayer, Codex, and a reviewing CA

The same case can be handed to a tax professional. LazyTax then behaves like an AI junior that prepares evidence and surfaces exceptions while the CA remains responsible for judgment and signoff.

The current build prepares and verifies. It does not accept portal passwords or OTPs, silently submit a return, or claim support for every Indian tax situation.

How we used Codex

Codex is the reasoning and coordination layer.

It understands the taxpayer’s request, reads the authorized documents, chooses the appropriate LazyTax tools, explains conflicts in plain language, and guides the next action.

Codex does not calculate tax in free form. Versioned TypeScript code performs the arithmetic and returns structured results.

Codex supplies intelligence. LazyTax supplies evidence, determinism, controls, and authorized rails.

Codex also helped us build the product. It decomposed the work into plugin, engine, MCP, testing, and demonstration workstreams. It implemented typed contracts, generated fixtures and tests, checked integration boundaries, and repeatedly exercised the complete workflow.

How we built it

LazyTax consists of an installable verification skill, a local MCP server, a deterministic tax engine, and an evidence viewer.

The workflow begins by creating one pseudonymous case. Documents are normalized into source linked evidence records rather than copied into an unstructured summary.

The reconciliation engine compares categories across sources and preserves disagreements. If a conflict cannot be resolved through deterministic rules, the workflow pauses for a human decision. That decision is recorded against the original evidence.

Once the case is reconciled, the tax engine compares the supported old and new regime calculations.

The final Tax Proof Pack contains:

Source references
Reconciliation decisions
Calculation steps
Assumptions and open items
Tax rule versions
A SHA 256 integrity hash

We also built an executable Trust Lab. It reruns the real MCP workflow and checks evidence coverage, replay stability, duplicate handling, privacy canaries, unsupported case rejection, maker checker separation, and proof pack integrity.

The public demonstration uses synthetic documents and does not claim production security certification.

Product decisions

We deliberately chose depth over broad but unreliable coverage.

The demonstrated engine supports a narrow individual tax profile and fails safely when a case moves beyond that boundary. We would rather identify one unsupported item clearly than hide it inside a plausible looking calculation.

We chose a plugin first experience because most taxpayers do not want another complicated financial dashboard. They want to attach their documents, ask questions in familiar language, and understand what needs attention.

We kept calculations outside the model because tax arithmetic should be repeatable and testable.

We preserved conflicting evidence because automatically choosing the most convenient number would destroy trust.

We kept submission, payment, and verification under human control because convenience should not remove accountability.

Finally, we designed one shared case for taxpayers and professionals. A taxpayer should not have to restart the process when professional judgment becomes necessary.

Challenges we faced

The hardest challenge was making the product useful without allowing it to become overconfident.

Tax documents use different names, periods, totals, and levels of detail. Two sources may both be correct while describing different components. Reconciliation therefore required more than simply comparing numbers.

Plugin portability was another practical challenge. Codex installs plugins into its own cache, so the final bundle could not rely on paths inside the development repository. We rebuilt the plugin as a self contained package and tested it from an isolated installation copy.

We also had to turn trust claims into behavior. Words such as “private,” “deterministic,” and “human reviewed” cannot remain marketing language in a high stakes product.

We added executable checks that fail when evidence is missing, identifiers leak, unsupported