Practical AI at Marka

AI adoption,
engineered for real work.

We use AI every day to plan, write, and review code, and we build our own agents for work items and telemetry triage. We bring that working practice to your organization, with clear boundaries and people in charge of every decision that matters.

Discuss your first AI workflow→See what we've built

Workflow: you assign a backlog item, the planner splits it into tasks, the worker implements them in an isolated sandbox, the reviewer posts a verdict, and you approve or reject the change. Nothing merges on its own.

Marka Agents software factory · illustrative flow

Engineering evidence

Not a slide deck.
A working system.

Three decades of delivery taught us to trust what we can test. So we adopted AI the same way: by building it into our own engineering, with recorded decisions, automated tests, and people accountable for the result.

Building business-critical software since
1993
Projects delivered across industries
0+
AI agents in our own software factory
0
Changes planned, built, and reviewed with AI agents
0+
Automated tests behind the factory
0+
How we work

AI writes.
Engineers decide.

Our engineers build with frontier coding agents from Anthropic and OpenAI. Models matter, but reliability comes from the engineering around them: context the agent can read, decisions it must respect, and review it cannot skip.

  1. Context the agent can read

    Our repositories carry instructions for AI agents and a shared domain glossary, so agents work in the team’s language, not their own.

  2. Plans before code

    Consequential changes start from a saved plan with acceptance criteria and checks. A person approves it before anything is built.

  3. Decisions on record

    Architecture decision records explain why the system is shaped the way it is, for engineers and agents alike.

  4. A second AI family reviews

    Consequential plans and finished changes get an independent review from a different model family before we call them done.

  5. People approve and merge

    Engineers approve plans and own every merge. AI speeds up the work; accountability stays with people.

our repositories
  • ├─ AGENTS.md
  • ├─ CONTEXT.md
  • ├─ docs/exec-plans/
  • ├─ docs/adr/
  • └─ tests/
independent review
other model family
merge
human approval

Illustrative view of how our repositories are structured

Built by Marka

Meet Marka Agents.

Our own software factory for Azure DevOps: five AI agents and one operator console. It runs on frontier models through Azure OpenAI, with the model and reasoning effort set per agent, and every run is visible in one place.

PR Reviewer
Reviews new pull requests in the repositories you enable, against each repository’s own rules, and posts a verdict with severity-ranked findings and suggested fixes.
Work Item Advisor
Checks stories and bugs for missing acceptance criteria, repro steps, dependencies, and risks, then drafts the clarifying comment.
App Insights Analyzer
Triages application telemetry on a daily schedule or on demand and drafts deduplicated Bugs. A person approves what gets published.
PlannerEarly access
Turns an assigned item into tasks with done criteria, or sends back the questions that block it.
WorkerEarly access
Implements those tasks in an isolated sandbox, builds, runs the tests, and opens one draft pull request.
MAgent Runs
sample data
  • Worker
    Chain
    Task 1290
    stage · tests
    Running
  • Planner
    Work item hook
    PBI 1287
    5 tasks planned
    Succeeded
  • PR Reviewer
    Pull request hook
    PR 214
    Changes suggested
    Succeeded
  • App Insights Analyzer
    Schedule · 06:00 UTC
    Telemetry
    2 Bug drafts
    Needs attention
  • Work Item Advisor
    Console
    Bug 1302
    Ready to start
    Succeeded

Illustrative operator console · sample runs

Software factory · Early access

Assign a work item.
Get back a reviewed pull request.

Three agents take an item from your Azure DevOps board to a pull request with a review attached. Your team still decides what to build and what to merge.

  1. 01
    You

    Assign the item

    Assign a backlog item or bug to the Marka agent on your Azure DevOps board. That is the only trigger.

    Assigned To · Marka agent
  2. 02
    Planner

    Split it into tasks

    Reads the item and the repository, then creates tasks with goals, files, done criteria, and checks. Thin items come back with questions.

    Tasks · plan comment
  3. 03
    Worker

    Write the code

    Implements the tasks in dependency order inside an isolated sandbox, builds, runs the unit tests, and commits to one branch.

    1 branch · 1 draft PR
  4. 04
    Reviewer

    Review the result

    Reviews the final commit once and posts a verdict with findings ranked by severity on the pull request.

    Verdict · findings
  5. 05
    You

    Approve or reject

    Your team reads one pull request with its review attached. Nothing merges on its own.

    Human merge

Best for work a developer could finish in a day.

  • Well-scoped backlog items
  • Reproducible bugs
  • Missing tests and validation
  • Small refactors inside one module

Infrastructure and pipeline paths are blocked from publication, and architecture decisions stay with your team. Early access: the full chain is built and covered by automated tests; general release follows live end-to-end validation.

Control by design

Give AI a role.
Define its limits.

The model proposes. Deterministic code checks the result and applies only what is allowed. That one rule shapes every agent we build, and every AI workflow we design with clients.

AI model · sandbox
Proposes

A review, a plan, or commits. No Azure DevOps credentials, no direct writes.

Trusted code
Checks, then applies
  • ✓result shape
  • ✓allowed actions
  • ✓publish policy
Azure DevOps
Permitted changes

Comments, tasks, and draft pull requests, under your publishing rules.

  • credentials

    The model never holds an Azure DevOps credential. Trusted code publishes every comment, task, and pull request.

  • rules

    Reviews use the repository’s rules from the base commit, so a change cannot rewrite the rules it is judged by.

  • scope

    The planner adds tasks and comments and changes only the parent item’s state and assignee. The worker cannot merge, and infrastructure and pipeline paths are blocked from publication.

  • publishing

    Read-only mode, dry run, and a minimum severity decide what reaches your engineers.

  • recovery

    Every step is saved before it runs, so interrupted work resumes where it stopped, and markers keep retries from repeating comments or pull requests.

  • tracing

    With tracing on, each agent run records model, tokens, and latency, without storing prompt or code text.

Designed to run in your own Azure subscription, on your own Azure OpenAI account.

Your adoption path

Start with one workflow.
Expand on evidence.

We bring clients the same approach we used on ourselves: one real workflow, clear limits, and a measured pilot before anything scales. Marka Agents is built for Azure DevOps; our adoption work starts from the workflows and systems you already run.

  1. 01

    Choose the work

    Pick one recurring task where AI can save real effort, and agree what better looks like.

  2. 02

    Set the boundaries

    Decide data access, allowed actions, human approvals, and how success is measured.

  3. 03

    Run a controlled pilot

    Start read-only, compare results with your current process, and track review effort and running cost.

  4. 04

    Expand on evidence

    Keep what works, refine what does not, and extend only where the results justify it.

Form

What work would you like
AI to take on?

Tell us about the process, codebase, or operation you want to improve. We’ll help you pick a sensible first workflow and the controls it needs.