Ship verified software with AI agents — without losing control.
Letco turns approved requirements into tested, documented code using Claude, Gemini, Codex and Grok. Your team defines the specification; Letco executes, verifies and repairs the result.
Runs locally or in isolated cloud environments · Human approval gates · Multi-model · Encrypted project data
Join the free pilot
We onboard a small cohort of teams at a time. Full platform access, free — with hands-on setup and a real engineer helping you ship.
Full access, free
The complete 4-stage pipeline — Analyze → Implement → Execute → Verify — with automated QA and multi-model support (Claude, Gemini, Codex, Grok). No credit card.
Hands-on onboarding
A dedicated engineer helps you set up your first project and reach a shipped result — not just a signup.
Limited spots
We take a small cohort at a time so every pilot team gets real attention. Reserve your spot before it fills.
A look at how Letco works
Every step of the software lifecycle in one place — from analysis to a verified, production-ready result.
Two problems. One platform.
Most teams arrive with one of two problems — either AI is already loose in the organisation and nobody can account for it, or delivery needs to go faster without giving up control of quality. Letco answers both, and you can start with either.
Get the AI your team already uses under control.
Developers are running AI coding tools on their own laptops today, with no record of what was sent where. Letco moves that work onto infrastructure you own — sandboxes, your own Kubernetes, or the whole platform on-premise — and keeps every session recorded and reviewable.
- Every AI session stored, exportable and reviewable across the account
- Execution in isolated environments instead of personal machines
- On-premise deployment where nothing leaves your perimeter
Turn an approved specification into verified software.
The full lifecycle: Letco takes a requirement through a four-stage pipeline — Analyze, Implement, Execute, Verify — plans the work, runs it, and has an independent auditor check the result against the spec before you accept it.
- Four-stage pipeline with an automated repair loop
- Independent verification against the documented requirements
- Missions: describe a goal, approve the plan, let it run the rest
- One living specification for the whole team, not just developers
AI can write code. It can’t ship production software.
Teams get a productivity boost, then spend just as long reviewing, fixing and re-doing what the AI produced.
Code ≠ Working Software
AI generates code in seconds — but making it correct, complete and production-ready is still manual work.
No Quality Gates
There is no independent check that the output actually meets the requirements before it ships.
Context Loss
Requirements and decisions drift as work moves between people, tools and phases.
Security Gaps
Independent studies repeatedly find more security issues in AI-generated code — and typical tools add no guardrails.
Tool Fragmentation
Analysis, coding, testing and monitoring live in disconnected tools that never share a source of truth.
Poor Analysis = Poor Output
Weak requirements produce weak software — no matter how fast the AI writes the code.
Humans lead. AI executes. 24/7.
The real efficiency gain isn’t speed of typing — it’s time of day.
- Humans do everything
- 8 hours / day active
- Analysis + coding + review
- Idle 16h / day
- Delivery bottlenecked by working hours
- 8h human — direction & strategy
- 16h AI autonomous — execution
- Zero idle time
- Deliveries compound overnight
- Teams leave Friday. Monday it’s built.
The Split
Humans = strategy. AI = execution. Always in control.
Always In Control
AI doesn’t decide what to build — only how to build what humans directed.
Compounds Overnight
Leave Friday with a feature designed. Monday it’s built, tested, documented.
Use the AI tools your team already pays for.
Letco runs on subscription CLIs — Claude, Gemini, Codex and Grok — instead of pay-per-token APIs, so your AI costs stay flat and predictable.
Pay-per-token API
Every generated token adds to your bill. The more your team uses AI, the more you pay — scale means higher bills, and no flat-cost model is possible.
Subscription CLIs
Built on Claude, Gemini, Codex and Grok subscriptions. Flat cost regardless of tokens, customers bring their own, and the platforms improve themselves — Letco inherits every upgrade automatically.
Predictable costs
Bring your own AI subscriptions — no API pass-through tax. Letco monitors usage per session, so costs stay flat and fully transparent as you scale.
Always the latest models
The AI labs ship upgrades constantly, and Letco inherits every one automatically — your team is never stuck on an outdated model.
Your tools, orchestrated
Built on the AI developer tools your team already uses — Claude Code, Gemini CLI, Codex CLI, Grok CLI and Antigravity. Letco adds orchestration and verification on top; it doesn’t replace your stack.
For the whole team — not just developers.
The only AI platform that covers the complete SDLC. Everyone contributes, everyone verifies.
Everyone shares one living project documentation. One truth, every perspective — under human governance.
Platform, not IDE extension
Competitors are developer tools bolted onto IDEs. Letco is built for the whole SDLC from day one — every role has a first-class seat.
Shared context
Analysis written by the PM is visible to the tester. Requirements are the source of truth for developers. No translation loss between roles.
One platform for every role
Developer-only tools stop at engineering. Letco gives product owners, analysts and testers the same first-class workspace, so the whole team ships together.
POC is dead. MVP is the new POC.
Implementation got cheap. Analysis became the new differentiator — and AI helps with that too.
New Products
POC → MVP → Product · Months of throw-away prototypes
Analysis → Production-ready · Days from idea to working software. Validate in the real product, not toy code.
Existing Products
Feature by feature, sequential · Roadmap measured in quarters
Multiple features in parallel · Roadmap measured in weeks. Same team, multiplied output.
The bottleneck shifted — implementation used to be the constraint. Now it’s analysis quality, and AI helps with analysis too. The advantage compounds for teams that move fast.
One source of truth. The loop never breaks.
A four-stage pipeline with a closed repair loop: the system finds defects, fixes them in parallel, re-checks, and iterates until the work is verified.
Living documentation
Everyone works from one source of truth that stays current as the project evolves.
AI has full context
The pinned specification and project knowledge are injected into every step of the build.
Independently verified
An adversarial “definition of done” auditor — separate from the author — checks the result against the spec.
The loop closes
Unresolved findings spawn linked follow-ups automatically — no human triage at merge.
It runs when you want it to
A run can be scheduled into weekly time windows in your own timezone — overnight, or outside business hours. Windows gate the dispatch of new phases only; work already running is never interrupted.
Limits pause it, not break it
When AI usage approaches the provider's limit the run pauses itself, then resumes on its own once usage recovers and it is back inside a window. A pause you triggered by hand stays paused until you say otherwise.
Describe the goal. Approve the plan.
A mission is the layer above everything else: rather than driving each session, plan and orchestration yourself, you say what you want and the mission agent decides which of them to use and runs them for you.
- 01
You describe the goal
In plain language. The mission agent asks clarifying questions in a short conversation and turns the answers into a task specification: the goal, what success looks like, and the approach it intends to take.
- 02
You confirm — nothing moves before that
The specification comes back for approval and the mission waits. This is a hard stop by design: the agent never starts work on its own, so the first thing it produces is a plan you can reject.
- 03
It runs the whole arc
The mission agent drives Letco's own building blocks as its hands — sessions, planning and orchestration — analysing, planning, building and verifying, instead of you stitching those steps together yourself.
- 04
It reports back, and you can steer
You get a result to review and a full trail of what was done. A mission can be paused, resumed or cancelled at any point, and when the agent reaches a decision it should not make alone it stops and asks.
Autonomous, not unsupervised — the difference is that the stopping points are built in rather than remembered.
The loop never breaks. The spec never drifts.
A repair loop makes AI output correct. Anti-drift spec governance is the durable layer on top that keeps it aligned with the original intent — so what ships is what was agreed.
The authoritative specification stays read-only, pinned and deterministically enforced across the whole orchestration — so the build never drifts from the original intent.
Read-only, pinned spec
The authoritative specification stays read-only, pinned and deterministically injected into every step — so the build can’t drift from what was agreed.
Authoritative spec artifacts
Intent, glossary, principles, use cases, architecture decision records (ADRs) and quality gates — one canonical source of truth for humans and AI.
Immutable decision history
Principle-bound, versioned ADRs record every decision, so nothing is silently overwritten and every choice stays traceable.
Bidirectional spec loop
Downstream discoveries feed structured spec-impact findings back to the spec, with a human approval gate on anything that touches core principles.
Portable across models
The governance layer travels to Claude, Gemini, Codex and Grok — only the enforcement is platform-specific, so your spec is never locked to one model.
Enterprise-grade platform. Security-first, isolation-first.
The foundation is live today — verification, security and flexible execution built in, not on a roadmap.
Autonomous QA
A multi-step pipeline: build check, runtime health, completeness scan, end-to-end tests, docs generation, severity scoring and automated repair loops.
Multi-Model AI
Claude, Gemini, Codex and Grok — through AI developer tools like Claude Code, Gemini CLI, Codex CLI, Grok CLI and Antigravity. Built on AI subscription plans, not pay-per-token APIs, so costs stay flat.
Enterprise Security
AES-256-GCM encryption at rest, layered authentication (JWT, OIDC, NATS), BIP39 recovery keys, isolated execution and security audit logging.
Isolated Execution
Cloud (Kubernetes), local Docker clusters and virtual PCs — fully isolated per session. Isolation is a security primitive, with no cross-session contamination.
Full-Team Platform
Not just for developers. POs, PMs, Analysts, Developers and Testers all work in one platform — everyone contributes, and everyone can verify.
Cost Optimization
AI subscription plans vs pay-per-token APIs, lean-core context compression, full usage tracking and per-session cost breakdown.
Fits where your team already works.
Letco does not ask anyone to move their repositories, their issue tracker or their chat. It connects to what is already there.
Your Git provider
Connect GitHub, GitLab or Bitbucket so cloud sessions can clone the repositories you already have. GitHub can also be connected as a GitHub App, which is the recommended route because it avoids handling OAuth secrets at all.
- GitHub
- GitLab
- Bitbucket
Where your team already talks
An in-app notification centre covers the day-to-day, and anything worth interrupting someone for can escalate outward. Channels are set per person or shared by a workspace, and personal alerts never leak into a shared channel.
- Slack
- Microsoft Teams
- Discord
Jira, both directions
Letco can comment on the Jira issue an escalation belongs to, and issues labelled for Letco arrive as work offers on the planning page, where a person accepts or dismisses them. The connection is set up once for the account; each person links their own Jira identity.
- Issue comments
- Labelled-issue intake
What the AI can reach
Context7 gives the AI current, version-specific library documentation instead of whatever it memorised — add “use context7” to a prompt and it pulls the real thing. Claude Code plugins can be switched on per person from a catalogue your administrators curate, or added from a GitHub repository; they load per session and never touch anyone's own configuration.
- Context7
- Claude Code plugins
Where teams put Letco to work.
Detailed write-ups with real numbers from pilot teams are on the way. Here is the shape of them.
Feature development
Take an approved specification for a new feature and run it end to end — plan, implementation, tests, documentation — with verification before it reaches review.
Legacy modernisation
Work inside an existing codebase: map what is there, plan the change in stages, and keep every step checked against the spec instead of drifting.
Automated QA
Point the verification pipeline at work that already exists — runtime, completeness, tests and documentation — and let the repair loop close what it finds.
A governance methodology for any team.
What it is
A lightweight governance framework for software projects. It works without any tooling — just structured files and discipline. Letco is the software layer on top.
Principles — the “why” and the “what never.” Testable rules that protect project identity.
Methods — the “how.” Processes for versioning meaning, managing conflicts and recovering from failures.
“The goal is not enforcement — it’s early warning. Surface emerging problems before they become serious.”
User Data Privacy
Content encrypted with per-user keys derived from your password, backed by a recovery phrase only you hold. After logout, the server holds only data it cannot decrypt.
Security as Architecture
Security is a condition of existence — not a feature. It can’t be overridden by business requirements.
Autonomy Under Human Control
AI works autonomously — the human has the final word. Four control levels: pause, disable, stop, delete.
Resilience & Recovery
Failures are inevitable — loss of work is not. Auto-recovery without user intervention.
Isolation & Fairness
Strictly isolated workspaces. No tenant data ever reaches another. Fairly allocated resources.
Cost Transparency
Every resource has a visible price — AI usage, sandboxes, execution time. Tracked per session.