peashoot
Start a projectMenu
peashoot

Write to us

brendan@peashoot.io

For engineering teams

Make AI a dependable part of how you ship.

Peashoot works with engineering teams on the system around the model: context, agent workflows, evaluation, developer tooling, and the infrastructure underneath. We build inside your codebase, measure against real work, and hand over something your team can run.

Start a conversation See the system

The system around the model: a task, code, documentation, and team rules are assembled into a context packet with task scope, relevant files, and acceptance checks. An agent loop plans, implements, and verifies, repairing failed verification. Checks run tests and evals. A person reviews the change at a human boundary before it becomes a review-ready change. Learning from each result feeds the next run.

Illustrative engineering workflow, not a product interface.

01Where it breaks

Better models are only part of the equation.

The opportunity is not just generating more code. It is making the path from task to trusted change work better.

  1. 01

    Context gets lost.

    Agents can miss the conventions, decisions, and dependencies your engineers take for granted.

  2. 02

    Work gets repeated.

    Fragile handoffs, unclear checks, and poorly scoped tasks can turn apparent speed into review and rework.

  3. 03

    Spend is hard to explain.

    More tokens and more activity do not tell you whether useful engineering work is getting done.

We work on the system around the model.

02The system around the model

Make the whole workflow work.

We connect the pieces that determine whether agents produce useful, reviewable work, and what that work costs.

01 Context

Give agents the context that matters.

Structure repository knowledge, instructions, retrieval, and memory so agents can find relevant information without carrying everything into every task.

  • Knowledge sources
  • Retrieval
  • Context assembly
  • Freshness

What we build

Context map, retrieval changes, and maintainable agent instructions.

Repository, documentation, and decision sources feed retrieval. Relevant material is selected into a scoped context packet with its provenance; other material stays in the source. Freshness checks keep the packet current.

02 Workflows

Turn one-off runs into repeatable workflows.

Design task boundaries, tools, handoffs, checkpoints, and recovery paths around the way your team actually ships software.

  • Task scope
  • Tools
  • Checkpoints
  • Recovery

What we build

A working workflow with clear checks, ownership, and failure handling.

A task moves through plan, implement, and verify. Failed verification returns to implementation through a repair loop. Verified work crosses a distinct human approval boundary for human review. There is no automatic production deployment.

03 Evaluation

Know whether the changes help.

Test alternatives on representative engineering work. Track quality, human intervention, latency, and cost, not just agent activity.

  • Representative tasks
  • Checks
  • Traces
  • Comparison

What we build

An evaluation set, a comparison method, and a clear account of tradeoffs.

One fixed set of representative tasks branches into a baseline and a candidate. Both are compared against the same review criteria: quality, human effort, latency, and cost. No winning result is assumed.

04 Cost

Spend capability where it earns its keep.

Examine model selection, routing, context size, retries, and caching against the quality requirements of each task.

  • Routing
  • Context budget
  • Retries
  • Cost per outcome

What we build

A tested routing and cost-control policy, with explicit quality constraints.

Tasks with different needs are routed through routine, complex, or escalation paths. All three paths converge on the same acceptance checks. Routing is constrained by required quality, not just model price.

Illustrative system designs

03Autonomy, matched to risk

Let agents run further where mistakes are cheap.

Not every change deserves the same freedom. We tier autonomy by consequence, so routine work moves fast and anything touching money, permissions, or compliance stays behind stronger checks.

  1. T1

    Run further

    Scope
    Docs, tests, fixtures, internal tooling
    Control
    Automated checks, spot review
  2. T2

    Checked

    Scope
    Product UI, read-only assistants
    Control
    Checks plus human review on every change
  3. T3

    Spec first

    Scope
    Integrations, data pipelines, payments flows
    Control
    Written spec, stronger verification, staged rollout
  4. T4

    People decide

    Scope
    Billing logic, permissions, compliance
    Control
    Agents assist; people author and approve

04And the software around it

Not every problem is an agent problem.

We also build the tools, services, integrations, and infrastructure engineering teams depend on.

  • 01

    AI engineering workflows

    Context, task boundaries, and checks that make coding agents dependable on real work.

  • 02

    Agent systems

    Tool-using agents with guardrails, recovery paths, and people at the right checkpoints.

  • 03

    Evaluation systems

    Representative task sets and harnesses that show whether a change actually helped.

  • 04

    Developer tooling

    CLIs, bots, and internal platforms that take friction out of shipping.

  • 05

    Internal automation

    Pipelines for the repetitive work that keeps landing on engineers.

  • 06

    Custom software

    Production services and applications, built to your architecture and standards.

  • 07

    Integrations

    Dependable connections between your product and the services it relies on.

  • 08

    Systems design

    Architecture, infrastructure, and observability for the next stage of scale.

The layers we work across

  1. L1Developer toolsCLIs, internal platforms
  2. L2Services and APIsthe contracts between systems
  3. L3Integrationsthird-party and internal systems
  4. L4Data and pipelinesmovement, quality, lineage
  5. L5Infrastructureenvironments, CI, observability

05How an engagement runs

Improve one real workflow. Then expand.

Start with a concrete bottleneck. Establish a baseline, implement a focused change, and evaluate whether it is worth taking further.

  1. Understand the system.

    Map the tools, repositories, context sources, checks, and handoffs around a representative workflow. Agree on what improvement would mean.

    OutputA baseline and a focused problem statement.

  2. Build the intervention.

    Implement a targeted change with your team: better context, a more reliable workflow, stronger evaluation, or more deliberate model routing.

    OutputWorking code or configuration, not just recommendations.

  3. Evaluate and hand over.

    Compare the result with the baseline, document tradeoffs, and make the implementation understandable and maintainable.

    OutputEvidence, documentation, and a clear next decision.

06Measurement

Measure the work. Not the hype.

We agree on measures that connect agent behavior to engineering outcomes. The goal is not maximum automation at any cost. It is useful progress with acceptable quality and effort.

01Delivery
Elapsed time for comparable work, including waiting and rework
02Quality
Acceptance checks, regressions, and review findings
03Human effort
Corrections, interventions, and review time
04Cost
Model and tool spend per accepted task, alongside human effort

Measures depend on the workflow and the quality of available data.

Start a project

Tell us what’s slow, manual, or ugly.

Bring the workflow, the website, or the system everyone works around. We will tell you plainly what we would build, and whether it is worth building.

Engineering teamsAgents, evaluation, tooling, infrastructureEmail us BusinessesWebsites, systems, automationEmail us

Or write directly