The open-source core is free and always will be. The services layer is where we add setup, customisation, integration and ongoing support — so you get the speed of autonomous agents without the operational overhead.
Hand us a requirements document. Our agent crew — Product Manager, Architect, Developer, Reviewer, QA — processes it end-to-end, with human approval gates you control.
We set up the full stack on your infrastructure — local models, a vector knowledge base ingested from your docs, CI/CD hooks, and the VS Code extension — tuned to your team's workflow.
AI models can reproduce code from their training data — including fragments under copyleft licences like GPL or AGPL. We set up agents that scan every AI-generated change for licensed or copyleft-tainted code before it reaches your repository, so your proprietary codebase stays clean and legally safe.
Continuous operation, model tuning, prompt iteration, and performance diagnostics. We monitor your agent runs and catch inefficiencies before they cost you.
Every team has its own coding standards and domain vocabulary. We encode them into agent personas, SKILL files and sandbox runners specific to your stack.
Move COBOL and PL-SQL systems onto modern stacks. A dedicated workflow analyses the source, migrates it, and proves the result against the original — so behaviour is preserved, not guessed at.
For regulated teams — secure deployment, vulnerability remediation and a review of the agent pipeline, so AI runs inside your controls rather than around them.
Connect the agents to your world — bespoke tools and MCP connectors that let the crew reach your internal APIs, databases and ticketing, not just your codebase.
All three frameworks are Apache 2.0 and fully documented. Run them yourself, contribute back, or fork for your own needs — free forever.
The open-source core is a complete, production-capable agents orchestrator — it coordinates a crew of specialised AI agents through the full software lifecycle. Professional tiers add what organisations need when self-service isn't enough.
Nine providers — fully local, frontier API, or any OpenAI-compatible endpoint. The router picks the right model per agent and per task tier; pin one yourself, or register your own. No lock-in.
We understand your codebase, stack, workflow constraints and what you need the agents to own versus what stays with your human team.
We deploy the orchestrator, configure semantic model routing, ingest your knowledge base, and write the SKILL files that encode your team's conventions.
We run the first project end-to-end together — spec, backlog, implementation, sandboxed QA — with your developers approving at each gate.
We hand your team full control once the system is tuned, or stay on retainer to handle model upgrades, optimisation and support as your usage grows.
An open-core program delivered across three repositories and two languages — from a Python orchestrator to a VS Code agent — on a steady, public release cadence.
First release of the LangGraph orchestrator — a self-healing pipeline of seven specialised agents (PM → Architect → Developer → Reviewer → QA → Final QA → Reporter) with pluggable extensions and human-in-the-loop approval.
Shipped mcp-ingest — a CLI that ingests PDF, DOCX, Markdown and text into an MCP-compatible vector store, giving agents project context before they write code.
Added a code-migration workflow (Analyzer, Migrator and Equivalence Checker for COBOL/PL-SQL → modern stacks), parallel developer fan-out arbitrated by a Code Judge, layered configuration, and Azure model providers. Published to PyPI.
BM25 context retrieval, lazy workspace loading and per-run token/cost telemetry keep large multi-agent runs efficient and observable.
Brought the agent crew into VS Code’s native chat as @devteam — a triage → planner → executor pipeline running on local Ollama or cloud models. Published to the VS Code Marketplace.
A fast, disciplined development cycle hardened the extension to v0.77.0 — adding on-demand skills, capability-based model routing, plan and shell-command approval gates, and a round of security fixes.
Bringing the same @devteam orchestrator to IntelliJ IDEA and the JetBrains IDE family — extending the platform beyond VS Code.
My Dev Team started as one engineer's weekend project — built on a simple conviction: that the hard part of AI development isn't the model, it's the organization around it.
“Intelligence isn't the only bottleneck in AI development. Organization is.”
— Alexander Bobrovsky, co-founder
What began as a personal experiment in coordinating AI agents grew into a company. Between us we'd seen the same failure mode everywhere — capable people and capable models, let down by the workflow connecting them. So we built the crew we wished we'd had: one that treats organization, cost and human approval as first-class.
25+ years of IT experience, including 15+ years in product and program management, with deep expertise in system design. Designed and delivered systems with five-nines (99.999%) availability, processing hundreds of millions of events per day in near-real time.
15+ years of hands-on software development across Java, Python and JavaScript/TypeScript — building and shipping production systems end to end, including DevOps and CI/CD.
The orchestrator, state and workspace run on your infrastructure. With Ollama, nothing touches an external server. Cloud models are opt-in only.
We encode your team's conventions into SKILL files and agent personas — code style, review criteria, commit format — so agents produce code that already passes your review.
Every run produces a per-agent token receipt and an optimisation diagnostic — identifying loops and context bloat before they accumulate into real spend.
Agents don't write code until the spec is approved. Shell commands ask before they run. Every file change is reviewable in your Git history like any human-authored commit.
Developer, Reviewer and QA loop until tests pass. Bugs route back to the developer automatically. You see the final output, not the iterations.
The core is Apache 2.0. Run it without us, fork it, extend it. Our commercial relationship is built on the value we add — not on trapping you.
All three repositories are fully open-source, documented and production-ready. Install them, run them yourself, and come to us when you want setup, customisation or ongoing support.
You pay for professional services. The software is always free. Model API costs are pass-through at cost — we don't mark them up.
The full open-source framework. Clone, install, run. Community support via GitHub Discussions.
We handle setup, customisation and the first engagements. You keep control; we handle the operational burden.
Ongoing partnership for teams that want agents continuously tuned as their codebase and models evolve.
Tell us about your project. We'll reply within one business day with an honest assessment of fit and a scoping proposal.
Or find us on GitHub
