AI-First Engineer

We’re building AI-native software for tax and accounting. This role architects and implements the systems that power our platform: multi-agent workflows, intelligent document processing, agentic reasoning loops, and the evaluation infrastructure required to keep autonomous systems reliable at scale.

You’ll design systems where AI is the primary architectural component, not a feature bolted on. Agent orchestration across complex tax workflows. Deterministic interfaces around stochastic models. Production systems that CPA firms depend on during their most critical periods.

The scope is fluid. You may go from designing agent state management for long-running document extraction to building eval harnesses for a return review agent that measure whether your agents are performing as intended. From architecting tool interfaces that connect agents to our platform to optimizing cost-accuracy tradeoffs across thousands of concurrent agent runs during tax season.

The boundaries between agent design, infrastructure, engineering, and product work are not rigid here. This is a senior role with high autonomy. You’ll partner directly with product and engineering leadership to translate business objectives into technical architecture, then own the implementation end-to-end.

What You’ll Work On

Agentic Systems

• Multi-agent architectures where AI agents process tax documents, extract and validate data, and complete end-to-end accounting workflows with human-in-the-loop oversight
• Agent coordination, tool design, context engineering, and state management over long-running workflows
• Evaluation and observability infrastructure: task completion rates, accuracy attribution, cost tracking per action, regression detection, hallucination monitoring
• Agentic reasoning loops with tool use, reflection, and self-correction capabilities
  
  

Document Intelligence

• Intelligent document processing pipelines for structured and unstructured financial documents at scale
• Vision models, layout-aware extraction and domain-specific validation layers
• RAG pipelines that retrieve and synthesize context from millions of tax documents with the precision accountants require
  
  

Platform & Infrastructure

• Event-driven architectures that handle concurrent agent execution without blocking user workflows
• MCP (Model Context Protocol) servers and integration layers connecting AI agents to existing accounting tools and third-party systems
• Production systems that scale from thousands to millions of requests and survive tax season without degradation
  
  

What We Are Building

These are active areas of work where you’ll have direct ownership:

• Agent trust in deterministic environments: Designing supervision, validation, and user interfaces that make non-deterministic agent output trustworthy for professionals with zero tolerance for error
• Long-horizon state management: State hydration for long running agentic workflows, failure handling, retries
• Tool abstraction for agents: Optimizing trade-offs between granularity and abstraction to enable token efficient, performant tools for our agents
• Observability - Signal extraction from agent trajectories. Attributing outcomes to specific reasoning steps
• Cost-accuracy-latency optimization at scale: Different document types, complexity levels, and client tiers
  
  

What We Look For

• First Principles System Thinking - We need hands-on engineers who execute from fundamentals and build systems that hold up as requirements shift.
• Willingness to work across the stack - The lanes for agent architecture, data, and product are converging fast. The best work happens when engineers move between them based on what the problem requires.
• Domain engagement. You don’t need a tax background. You do need the inclination to understand the workflows your agents are performing. That context is what separates good agent design from demo-quality output.
• Ownership of outcomes
• Speed and reliability. You need to operate with urgency without creating systems that break under pressure.
  
  

Strong Candidates Have

• At least 4 years of Core Engineering Experience (Language or stack agnostic)
• Built agentic workflows or autonomous systems that made real decisions in production, not demos
• Shipped AI features that handled edge cases, failures, and real-world messiness at scale
• Some experience with document intelligence, form understanding, or processing unstructured financial data
• Optimized LLM costs at scale without sacrificing quality
• Built in regulated industries or high-reliability environments
• Open-source contributions, technical writing, or other evidence of deep technical expertise