THE PLATFORM
One platform for the whole software lifecycle — new code and old.
DevCurrent is a platform where specialised AI agents specify, design, build, test and modernize software, while your people approve what matters.
THE STUDIO
From a rough idea to a certified specification.
The Studio interviews you about the idea, gives it a readiness score, finds contradictions and assumptions and resolves them with you. When the specification is ready, a named approver signs and it is stamped certified.
Read the text in the film
- A rough idea in. A certified brief out. You answer questions. The spec writes itself.
- You arrive with a rough idea — and whatever context you already have.
- The Studio interrogates it — confirmable scenarios, each decision logged as you go.
- You're answering questions, not writing a document. The spec builds itself from your answers.
- A complete spec assembles — requirements, a data model, state machines, numbered rules.
- User stories and acceptance criteria too — nothing left implicit.
- When it's complete and consistent, the brief is certified.
- You exit with an exportable reverse brief — ready to plan and build from.
HOW IT WORKS
One governed pipeline — a specialised agent for every role.
A brief or an existing repository goes in. Specialised agents run the whole software lifecycle, from specification and design through data, backend and frontend to review and release. Every layer is reviewed and tested before the next begins, failed checks are fixed automatically, and every stage leaves a reviewed result and an audit entry.
- 1 · Specify and plan Requirements collectorRequirements analystProject planner Approval
- 2 · Design Solutions architectArchitecture reviewUX designer Approval
- 3 · Data Database engineerCode reviewTesting Approval
- 4 · Backend Backend developerCode reviewTesting Approval
- 5 · Frontend Frontend developerCode reviewTesting Approval
- 6 · Review and ship Security and standardsFinal code reviewTechnical writerDevOps Approval
Read the text in the film
- One governed pipeline. A brief enters. 19+ specialized agents ship it — humans in control at every gate.
- Specify & Plan — the brief becomes a certified spec and a tracker-ready backlog.
- Design — architecture is drawn, reviewed, then the UX. Each agent reads the last one's output.
- Data layer — built, then reviewed and QA'd before anything moves on.
- A check fails — so an automatic fix loop re-runs the work until it passes.
- Passed. The layer is complete and gated.
- Backend layer — built directly on the real data layer, not a mock.
- Frontend layer — the final layer, reading real backend output.
- Review & Ship — security, code review, docs, and deploy.
- Final review finds an issue — the work is sent back to the Frontend layer to fix.
- The fix flows forward again — every stage re-runs and is re-approved.
- Cleared at every gate — now it ships.
- Governed, end-to-end, automated. Every stage reviewed and gated · nothing ships without a human yes.
ON YOUR TERMS
Fully autonomous. Fully gated. You set the dial.
The same pipeline runs at any level of autonomy, from zero-touch runs to a human decision at every stage.
Fully autonomous
End-to-end runs with automatic fix loops and no human touch
Good for: Prototypes, internal tools, evaluations
Hybrid
Gates exactly where you want them, for example automatic through the build with sign-off on security and release
Good for: Teams that trust the build and want control at the edges
Fully gated
Every stage pauses for its assigned person, so the right reviewer gates the right work
Good for: Regulated work and the public sector
Governance never switches off. At every level, every run produces the same reviewed results, audit trail and cost controls.
VALUE BEFORE YOU BUILD
Value before a single line is built.
You don't have to go all the way to get something out. Stop after the specification, with a backlog straight into Jira or Azure Boards, or after a clickable prototype your stakeholders can sign off.
BROWNFIELD INTELLIGENCE
The hardest, most valuable case: changing software that already exists.
- Every language, from COBOL, VB6, Delphi and PowerBuilder to C#, Java, Python and TypeScript.
- Whole estates across many repositories.
- A structured understanding of the system: its parts, interfaces, data, dependencies and business rules, each cited to the code.
- An impact map before every change.
- Modernization proven to behave the same, always to the newest versions.
- Security, architecture and test-coverage audits.
Read the text in the film
- Brownfield intelligence. Understanding software that already exists — well enough to change it safely.
- Most real engineering is brownfield — changing software that already exists, spread across many repositories.
- Cross-repo federation — many repos are read as one connected system.
- A structured model is assembled — entities, public interfaces, integration seams.
- A dependency graph across architectural layers — including the system's own blind spots, with a confidence score.
- Impact mapping — the blast radius of a change is mapped before a single line is touched.
- Three deterministic engines run in parallel — security, architecture, and test generation.
- Each pass is deterministic and explainable — it emits a fingerprint, not a guess.
- Findings assemble into a report — versioned and diffable against the last run.
- Re-run it and the fingerprint is identical. Reproducible — not a black box.
GOVERNANCE
Governance built in, not bolted on.
Approval at the gates you choose, roles and permissions per workspace, spend caps that stop spending when reached, and a full audit trail of every decision and every model call.
LEARNING
A workspace that learns.
DevCurrent learns from your reviewers' decisions — what they approve, reject and correct — and applies the lesson once you have approved it.
SOVEREIGNTY
Your models. Your cloud. Your region.
Any model
Claude, GPT, Gemini, GLM, Llama, Mistral and other open-source models, or your own. Choose per workspace, even per agent.
Where you need it
In Europe for European organisations, in the US for American ones, or strictly inside your own environment. Your AWS, Google Cloud or Azure account in the region you choose, or your own servers, even with no internet access.
Nothing leaves
The platform sends nothing to us, no telemetry. Your code and data stay in your environment; in a joint pilot, our people work with them only there, alongside your team.
Fully sovereign when you need it
On your own servers with open-source models, DevCurrent runs with no third party involved at all.
European by birth
DevCurrent AS is a Nordic company, based in Oslo.
WORKS WITH YOUR TOOLS
Fits the tools you already use.
- Code
- GitHub, GitLab, Bitbucket, Azure DevOps
- Planning and documentation
- Jira, Confluence, Azure Boards
- Collaboration
- Slack, Teams, Figma
- Sign-in
- Entra ID, Okta, Google or Auth0, with SCIM
- Developers
- Claude Code or any MCP client can drive DevCurrent.
SIX JOURNEYS
Six journeys — from first idea to running system.
Every journey runs faster, holds the same quality and costs less than doing it the old way. One platform for the whole team: product owners, architects, developers, testers and security leads work in the same journey, each at their own gate.
The Studio interviews you, finds the gaps and contradictions, and turns the idea into a complete, certified specification, ready to plan and build. See the journey → Specification to clickable prototype Stakeholders won't sign off on a document. They need to see it.
A clickable prototype straight from the specification. Feedback and sign-off come before a single line is built. See the journey → Existing system to new features New features are needed, but every change in a tangled codebase is a risk.
DevCurrent maps your code and the impact of the change first, then builds, reviews and tests the feature safely. See the journey → Legacy to modern system An ageing system nobody dares touch, and modernization quotes measured in years.
DevCurrent understands the old system, decides with you what to carry, redesign or drop, rebuilds it on a modern stack, and proves it still behaves the same. See the journey → Specification to production The specification is signed off, but building it still needs a team and months you don't have.
The full pipeline — architecture, data, backend, frontend, tests, security review and deployment — with your approval at every gate. See the journey → Existing code to audit report No one knows what is really in the code: the risks, the weak spots, the untested parts.
A full security, architecture and test-coverage audit, with the fixes and the missing tests ready to apply. See the journey →
See the platform at work.
We'll show you a journey that matches your problem. We reply within one working day.