Skip to content
Mekar

Agentic engineering you can govern, verify and account for.

Mekar runs your AI coding agents on infrastructure it hosts and operates, and accounts for every run. It meters what each agent costs, flags runs that stall, stops runaway loops and ties each dollar to a reviewed result, so engineering teams cut wasted spend and developers stop monitoring agents and get back to higher-impact work.

Fully hosted: Mekar runs the agent runtime and database for you, so your team has no agent infrastructure to deploy or maintain.

AI spend by ticket

$40.25

42% of $95.00 budget used

3 tickets
  • MKR-1042

    Migrate billing service to v2 API

    $18.40 / $40.00

    Done

  • MKR-1038

    Harden SSO session handling

    $9.75 / $25.00

    Awaiting human

  • MKR-1031

    Add audit export for compliance

    $12.10 / $30.00

    In progress

Illustrative example of per-ticket AI spend against budget.
See where AI spend goes
Every agent run records provider cost, tokens and model against the ticket that requested it, with spend shown against each ticket's budget and an organization-wide total, on a managed LLM key or your own.
Agents that do not need watching
Each ticket is questioned at intake to expose hidden decisions, iteration limits and stuck-agent detection stop unproductive runs, and every result arrives with automated testing evidence.
ROI on every outcome
Each dollar is tied to its requirement, the work the agent delivered and the named reviewer who approved it, so you can see what every delivered outcome cost.

Mekar in brief

What is Mekar?

Mekar is an AI agent infrastructure platform for AI and LLM engineering teams. It runs AI coding agents against your tickets on infrastructure Mekar hosts and operates, records what every agent run costs, flags runs that stall, stops runaway loops and ties each dollar to a result a named reviewer approved. Teams use Mekar to cut wasted AI spend, make agent work reliable and stop developers from monitoring agents, so they can focus on higher-impact work.

Who is Mekar for?

Mekar is built for AI and LLM engineering teams that run coding agents and answer for what those agents cost and deliver. Engineering leaders use Mekar to see where AI spend goes and what it returned. Platform teams use it to run agents without operating agent infrastructure themselves, on a managed LLM key or their own. Developers use it to hand work to agents without watching every run.

What problem does Mekar solve?

Mekar solves three problems AI teams hit once coding agents do real work: spend they cannot attribute, agents someone has to watch, and returns they cannot measure. LLM provider billing reports spend by account, project or API key rather than by task, agents that stall or loop keep consuming budget, and agents that guess at unstated requirements produce work that is redone after review.

How does Mekar help AI engineering teams?

Mekar helps AI engineering teams in three ways: it shows where AI agent spend goes, keeps agents reliable without anyone watching each run, and records the return on every dollar by tying it to an approved outcome.

  • Where is our AI agent spend going?

    The problem
    Provider bills show totals per account or key, so spend cannot be traced to the ticket, team or task that caused it.
    How Mekar solves it
    Mekar records provider cost, input and output tokens and model for every agent run against the ticket that requested it, counted once across retries and restarts, and shows spend against each ticket's budget beside an organization-wide total.
    Explore AI spend management
  • How do we keep agents reliable without watching them?

    The problem
    Agents that stall, loop or guess at unstated requirements waste budget and send developers back to check every run.
    How Mekar solves it
    Mekar questions each ticket at intake to settle hidden decisions, stops unproductive runs with iteration limits and stuck-agent detection, and attaches automated testing evidence to each result: the tests, type-checks, lint and builds the agent ran.
    Explore agent reliability monitoring
  • What return are we getting on AI spend?

    The problem
    Finance sees the provider bill and engineering sees the pull requests, but nothing connects a dollar to the outcome it bought.
    How Mekar solves it
    Mekar links every dollar to its requirement, the output the agent delivered and the named reviewer who approved it, so each delivered outcome has a recorded cost.
    Explore AI ROI tracking

Platform capabilities

From a clarified ticket to a verified, accounted-for outcome

Mekar gives engineering, finance and security leaders one governed system of record for AI-assisted delivery: the decisions settled before work began, what the agents did, the evidence that it works, what it cost and who approved it.

Built into every ticket

Agents start from a clarified brief and finish with evidence that the work runs, so less is redone after review.

  • Question grilling at intake

    Before an agent writes any code, Mekar questions each new ticket to expose hidden decisions early: the scope, design and edge-case choices nobody wrote down. Every question comes with concrete options and a recommended choice, and your answers become part of the ticket's requirements, so work is built on decisions you made instead of guesses you discover in review.

  • Automated testing evidence

    Every delivered ticket comes with proof that the work runs. Mekar records each test, type-check, lint and build the agent ran with its result, screenshots of the changed screens, and the scenarios it exercised by hand, and attaches them to the pull request. Reviewers verify the outcome from the evidence instead of re-running everything themselves, and an approval is backed by results, not the agent's word.

AI spend management

Know what every agent run cost, to the token

LLM provider bills total usage per account, workspace or API key, so they cannot say which work the money paid for. Mekar meters each agent run against the ticket that commissioned it, whether it runs on a Mekar-managed LLM key or your own, so finance and engineering work from one set of figures.

Markup on BYOK usage
0%
Sub-cent costs shown to
8 decimals
Usage double-counted
Never

Usage ledger · MKR-1042

Metered per ticket
EventModelTokensCost
Initial runclaude-sonnet412,380$3.21845
Follow-upclaude-sonnet96,115$0.74102
Status pollclaude-sonnet0no new usage
Retry after failuregpt-4.1188,904$1.40467
Ticket total$5.36414
Illustrative example. Polls and restarts add no cost, because only new model usage is recorded.
  • Per-ticket cost attribution

    Every agent run records provider cost, input and output tokens, and model against the ticket that requested it, so each line of spend has an owner.

  • De-duplicated metering

    Cumulative provider usage is reconciled into a transactional ledger. Retries, follow-ups and worker restarts are never counted twice.

  • No hidden cost from failed work

    Failed runs are metered like successful ones, and historical runs are reconciled automatically, so the total reflects all of the money spent.

  • Budget visibility at intake

    Set a budget when work is commissioned and track spend against it on every ticket, alongside an organization-wide AI spend total.

  • Managed key or bring your own

    Start on an LLM key Mekar manages for you, or bring your own Anthropic, OpenAI, OpenRouter, Google Gemini or OpenAI-compatible keys. With your own key you pay providers directly, and Mekar adds no markup.

  • Credential-pinned billing

    Each run stays billed to the credential it started with. Changing a default key never moves in-flight cost to a different account or cost center.

  • Route to your own model gateways

    Send agent traffic to model gateways you run or negotiated-rate endpoints through any OpenAI-compatible base URL, and meter it in the same ledger.

  • Runaway-loop guardrails

    Iteration limits and stuck-agent detection stop unproductive runs from consuming budget without making progress.

Cost visualization dashboard

What does Mekar's cost dashboard show?

Mekar's cost dashboard is the Analytics page of the Mekar console. It charts AI agent spend over time and breaks it down by repository, model, user, run outcome and workspace, next to what that spend delivered: agent pull requests, cost per merged pull request, and files changed and tests added per dollar. Every figure comes from the same de-duplicated usage ledger as ticket costs, so the dashboard and each ticket's cost agree.

Mekar gives AI and LLM engineering teams cost transparency without a spreadsheet: instead of one provider total per API key, you see which codebase, model, person and kind of run the money went to, and how much of it paid for work that shipped.

Spend analytics · All workspaces

Last 7 days
AI spend
$355.66Last 7 days
Tokens
48.6M43.9M in · 4.7M out
Spend on successful runs
80%$284.90 of $355.66
Cost per merged PR
$8.6223 merged pull requests

Spend over time

  1. Mon: $48.12
  2. Tue: $71.40
  3. Wed: $66.05
  4. Thu: $89.37
  5. Fri: $58.90
  6. Sat: $12.64
  7. Sun: $9.18

By model

  • claude-sonnet62%
  • gpt-4.127%
  • gemini-2.5-pro11%
Illustrative layout of the Mekar Analytics page with sample figures, not customer data.

What does the cost dashboard break AI spend down by?

  • Spend over time

    Spend per hour for the last 24 hours, or per day over the last 7, 30 or 90 days or 12 months, with input and output tokens beside every total.

  • Spend by run outcome

    Runs that succeeded, failed, stopped early or were still running, so the cost of failed and abandoned work is visible instead of buried in a total.

  • Spend by repository

    Which codebases consume agent spend. A ticket that targets several repositories is metered per repository.

  • Spend by model

    Spend and token volume for each model and LLM provider, using the model each run actually selected.

  • Spend by requester

    Spend attributed to the person who created the ticket, so usage can be discussed with the people who asked for it.

  • What the spend delivered

    Agent pull requests opened and merged, cost per merged pull request, files changed and tests added per dollar, checks passed or failed, and the average coverage change, with each pull request linked to its ticket.

  • Spend by workspace

    At organization scope, spend for each workspace side by side. Switch workspace to scope every chart to one workspace.

How do teams use Mekar's cost dashboard?

  • Engineering leaders

    Monthly AI spend review

    Open the last 30 days and read three numbers together: total AI spend, the share spent on successful runs, and cost per merged pull request. Reading them together each month shows whether agent work is getting cheaper per delivered change, not just whether the bill went up.

  • AI and platform engineers

    Choosing models on evidence

    Use the model breakdown to see which models carry most of the spend and token volume before you change a default model or route traffic to your own OpenAI-compatible gateway, then check the same view after the change.

  • Finance and FinOps

    Allocating AI cost to teams

    Break spend down by workspace and repository to attribute AI costs to the teams and products that incurred them. Retries and worker restarts are counted once, so no team is charged twice for the same usage.

  • Team leads

    Catching wasted runs early

    Switch to the last 24 hours to see spend per hour and how much went to failed or stopped-early runs. From the pull request list, open the ticket behind an expensive change and replay what the agent did.

How current and complete are the dashboard figures?

Mekar updates the dashboard from an hourly batch, so totals lag by up to about an hour and the current hour appears after the next update. Pull request costs are live.

Time ranges
Last 24 hours (hourly); last 7, 30 or 90 days or 12 months (daily)
Freshness
Hourly batch; the page refreshes every five minutes or on demand
Breakdowns
Repository, model, user, run outcome and, at organization scope, workspace
Source
The de-duplicated per-run usage ledger, with dimensions captured when each charge is recorded
Not included
Exports and custom date ranges

Agent reliability monitoring

How does Mekar monitor AI agent reliability?

Mekar's agent reliability monitoring tracks every AI agent run from the moment it is queued until its work is published. Mekar workers check in every 15 seconds, and each executing run shows its health on the board and on its ticket. When a run waits too long for a worker, loses its worker, stops reporting model usage or nears its step limit, Mekar names the problem and records it on the ticket timeline.

Mekar frees developers from monitoring agents: instead of keeping a terminal open for every run, they open a ticket when Mekar flags it, answer the questions the agent asks, and review a result that arrives with its testing evidence. The infrastructure failures in between, such as worker restarts, step limits and interrupted sessions, are recovered without a person.

Run health · In progress

MKR-1047 · Executing

Split the billing worker into queue consumers

Step 182 of 300 · segment 2 of 3 · 61% of this segment

Worker checked in 6 s ago · last model usage 21 s ago

  • MKR-1049

    No new model usage for 16 min · worker checked in 9 s ago

    Possible agent stall
  • MKR-1051

    Not claimed by a worker for 3 min

    Queued for worker
  • MKR-1044

    Committed work is in draft PR #212

    Stopped before finishing
  1. 14:02 Worker claimed run
  2. 14:31 Step limit reached; continuing (1 of 2)
Illustrative layout of Mekar run health with sample runs, not customer data.

Which agent health signals does Mekar monitor?

Mekar reports seven named run-health states. Each one says what happened, when Mekar raises it and what happens next, so a developer can tell at a glance whether a run needs them.

Mekar run-health signals, when each is raised and what happens next
SignalWhen Mekar raises itWhat happens next
Queued for workerNo worker has claimed the run for two minutes.The label shows the run is waiting for worker capacity, not that the agent is stuck.
Worker unresponsiveThe worker's two-minute renewable lease on the run expires.Another worker in the organization can reclaim the run and resume its agent conversation.
Possible agent stall15 minutes pass with no new reported LLM usage while the worker keeps checking in.A warning, not a timeout: the run keeps executing, View full conversation opens it where it is, and resumed usage is recorded as a recovery.
Step limit approachingThe run passes 80% of its last step-limit segment, for example Step 241 of 300.Mekar shows the warning in run health and records one timeline event before the limit is reached.
Step limit reached; continuingThe session reaches its step limit, 300 steps by default.The same session continues with all its work, up to two times by default, instead of failing.
Feedback requestedThe agent hits a missing decision or conflicting requirements.The ticket moves to Awaiting human with up to five structured questions, and answering them resumes the same conversation.
Stopped before finishingThe run fails after its continuations, on a provider error, on stuck detection or with no final response.Committed work is published as a draft pull request marked Incomplete, and Retry resumes the failed session.

How does Mekar recover agent runs without a developer?

  • Continue at the step limit

    A run that reaches the step limit is not failed. Mekar records Step limit reached; continuing (1 of 2) and continues the same session, so a large change keeps its progress instead of starting over.

  • Survive worker restarts

    Each run is claimed by exactly one worker under a renewable lease. If that worker disappears, another worker reclaims the run and resumes its conversation.

  • Stop runaway loops

    Step limits and stuck detection end agents that repeat themselves without progress, so a loop cannot run indefinitely.

  • Never drop committed work

    A run that stops early still pushes its commits as a draft pull request headed Incomplete, with the reason it stopped.

  • Retry without exploring again

    Retry resumes the failed attempt's session on the same model and tells the agent why it stopped, keeping the ticket's cost and event history.

  • Ask instead of guessing

    When a decision is missing, the agent stops and asks up to five questions at once, each with suggested answers and a recommendation. One sitting answers them all, and the agent resumes where it paused.

  • Correct course mid-run

    A follow-up prompt reaches the running agent's conversation. After a run ends, it starts a new run that carries the ticket's full requirements history.

How does reliability monitoring reduce developer intervention?

  • Developers

    A run goes quiet during a long test suite

    Without monitoring, someone checks the terminal to see whether the agent is still working. With Mekar, the run stays Executing while its worker checks in, and only 15 minutes without new model usage raises Possible agent stall, with a link to the full conversation.

  • Developers

    A large refactor runs out of steps

    Mekar warns at 80% of the step limit, continues the same session when the limit is reached and, if the run still fails, publishes the commits as a draft pull request. The developer reviews the draft or clicks Retry instead of re-prompting from scratch.

  • Platform teams

    A worker restarts mid-run

    The expired lease shows as Worker unresponsive, and another worker reclaims the run and resumes its conversation. Usage is de-duplicated in the ledger, so the restart is not billed twice and nobody has to restart the ticket.

  • Engineering leads

    A ticket leaves a decision open

    Instead of guessing and having the work redone in review, the agent moves the ticket to Awaiting human with structured questions. The lead answers them in one pass and the same conversation resumes.

What are the limits of Mekar's reliability monitoring?

Mekar never kills or fails a run because it has gone quiet: long tool calls and tests can be silent, so the stall signal is a warning for a person to act on. Run-health signals appear on the board, the ticket and its timeline. Uncommitted changes are never published, and cancelled runs publish nothing.

Worker check-in
Every 15 seconds, with a two-minute renewable lease per run so each run executes once
Queued signal
After two minutes without a worker
Stall signal
15 minutes without new reported LLM usage; a warning, never an automatic timeout
Step limit
300 steps per session segment by default, with up to two continuations
Live view
The board refreshes every 3 seconds and an open ticket every 2 seconds
Failed runs
Metered like successful ones and shown as spend by run outcome

AI ROI tracking

How do you measure AI ROI?

Mekar measures AI ROI by recording, for every agent run, what it cost and what it produced. Each ticket keeps its requirements, every run's provider cost and tokens, the agent's output, its pull requests with files changed, tests added and check results, and, when the ticket has a reviewer, that person's approval. Mekar rolls those records up into cost per merged pull request, files changed and tests added per dollar, and verification pass rate, overall and by repository.

Mekar lets AI and LLM engineering teams demonstrate the return on AI spend with records instead of estimates: every figure in an ROI review links back to the tickets, pull requests and approvals it came from, so a finance partner or engineering leader can check the number rather than take it on trust.

What the spend delivered · Last 30 days

Checks passed: 2 of 4

Cost per merged PR
$14.02$42.05 across 4 PRs
Files changed per $
0.832 files
Tests added per $
0.416 tests
  • MKR-1042billing#318 · merged14 files · 9 tests · checks passed$18.40
  • MKR-1036web#1204 · merged6 files · 4 tests · checks passed$7.85
  • MKR-1033api#527 · merged9 files · 3 tests · checks failed$11.20
  • MKR-1029worker#88 · closed3 files · 0 tests · checks failed$4.60
Illustrative layout of Mekar delivery reporting with sample figures, not customer data.

Why can't LLM provider billing show AI ROI on its own?

Mekar exists because provider billing stops at the cost side of ROI. LLM providers such as Anthropic report usage and cost by organization, workspace, API key and model, but not by the task an agent was doing or whether its result was kept, so a bill cannot say what the spend returned. Source: Anthropic Usage and Cost API documentation.

What LLM provider billing and Mekar each record about AI spend
QuestionLLM provider billingMekar
Who or what is the cost attributed to?Organization, workspace, API key and modelThe ticket, repository, model and requesting user of each agent run
Is the outcome recorded?No; the bill has no notion of a task or its resultPull requests opened and merged, and the approval of the ticket's named reviewer
Is the quality of the work recorded?NoFiles changed, tests added, coverage change and the result of each test, type-check, lint and build command the agent ran, per pull request
Is the cost of failed work separated?No; failed and successful calls are billed alikeSpend by run outcome: succeeded, failed, stopped early or still running
Can a figure be traced to the work behind it?Only to a key or workspaceEvery pull request links to its ticket, requirements, conversation and timeline

Which AI ROI metrics does Mekar track?

  • Cost per merged pull request

    The agent cost of every pull request opened in the period, including PR-feedback rounds and retries on the same branch, divided by the number that merged. Unmerged work counts against the figure, so it cannot be flattered by leaving out abandoned changes.

  • Files changed per dollar

    Files changed across agent pull requests for each dollar of agent spend, with lines added and deleted beside it.

  • Tests added per dollar

    Net test declarations added per dollar. Removed tests are subtracted, so renaming a test does not inflate the count.

  • Verification pass rate

    How many pull requests passed or failed the test, type-check, lint and build commands the agent ran, counted only when an exit code proves the result.

  • Average coverage change

    The mean change in test coverage, in percentage points, across pull requests whose test output reported a coverage figure.

  • Share of spend on successful runs

    The part of AI spend that went to runs that succeeded, next to the cost of failed and stopped-early runs.

  • Cost per delivered outcome

    Each ticket brings together its spend, its requirements, the agent's final output and its approval status, so even research and analysis tickets without a repository have a recorded cost per result.

How does Mekar connect AI spend to business outcomes?

Mekar keeps one unbroken record from the request to the accepted result. Each link in the chain is stored when it happens and is never overwritten, so the cost of an outcome can be audited after the fact.

  1. 01

    Requirement

    The brief and every follow-up, with author and timestamp

  2. 02

    Agent run

    Every instruction, tool call and observation, kept for replay

  3. 03

    Spend

    Provider cost and tokens, metered once across retries

  4. 04

    Pull request

    Files, tests, checks and coverage, with its agent cost

  5. 05

    Approval

    Accepted by the ticket's named reviewer, when one is assigned

  • Requirements history that is never overwritten

    The original brief and every follow-up are kept in order with their author, so a change in scope, and the cost it added, can be traced.

  • Full conversation replay

    Review every instruction, agent action, tool call and observation across all runs of a ticket to see how a result was produced and why it cost what it did.

  • Execution timeline

    A time-ordered record of each worker claim, run, failure, retry and approval explains where time and money went on a ticket.

  • Per-repository attribution

    A ticket can target several repositories. Each target gets its own tracked run and pull request, so cost and outcome stay attributable to each codebase.

  • Retries stay on the bill

    Retrying a failed ticket keeps its earlier cost, input, output and event history, so the full price of an outcome includes the attempts that failed.

  • Delivery board

    Tickets move from Ready to In progress, Awaiting human, Done or Failed on a board that refreshes every few seconds, showing agent throughput and failure rate.

How do teams use Mekar to demonstrate AI ROI?

  • Engineering leaders

    Justifying the AI budget

    Bring cost per merged pull request, tests added per dollar and verification pass rate for the last 90 days to the budget review. Each pull request in the list links to its ticket, so any figure can be opened and checked during the meeting.

  • Finance and FinOps

    Charging AI cost back to products

    Break agent spend down by workspace and repository, and delivery by repository, to show each product team what its AI usage cost and what it shipped. Usage is metered once, so retries and worker restarts never double-charge a team.

  • AI and platform engineers

    Comparing models on delivered work

    Before and after switching a default model or routing traffic to your own gateway, compare cost per merged pull request and verification pass rate, not just price per token. A cheaper model that fails more checks can cost more per change that ships.

  • Team leads

    Finding where spend is wasted

    Sort pull requests by cost and open the expensive ones that failed checks or never merged. The ticket's requirements history and replay show whether the money went on an unclear brief, a retry loop or a scope change.

What does Mekar's ROI tracking not measure?

Mekar measures the cost and engineering output of agent work, not its business value in revenue or hours saved, and it does not compare agent work with what a developer would have cost. Those judgments stay with your team, and Mekar's records give them an auditable base.

Spend source
The de-duplicated per-run usage ledger, the same one ticket costs use
Delivery source
Evidence recorded each time an agent run publishes to a pull request
Freshness
Spend totals update from an hourly batch; pull request costs are live
Checks
The commands the agent ran in its own session, not your CI pipeline
Coverage
Only figures found in that run's test output, when the repository can measure coverage
Not included
Revenue impact, time-saved estimates, exports and custom date ranges

Use cases and workflows

How do AI engineering teams use Mekar?

Mekar is used by AI and LLM engineering teams in workflows that combine its cost dashboard, agent reliability monitoring and ROI tracking. The three workflows below follow a team from a question, such as why spend jumped or whether a pilot worked, through the Mekar screens that answer it, to a decision backed by records.

Which Mekar workflow fits your team?

Mekar workflows by team, starting point, capabilities used and result
WorkflowUsed byStarts whenMekar capabilitiesResult
Trace a spend spikeTeam leads and engineering leadsThe weekly spend review shows agent spend jumped, mostly on one repository.Cost dashboard, ROI tracking, Agent reliabilityThe cause of the spike, a corrected ticket, and a cost per merged pull request that still includes the failed attempts.
Ship a multi-repository changeDevelopers and platform teamsOne change has to land in an API and in the web app that calls it.Ticket intake, Agent reliability, ROI tracking, Cost dashboardOne pull request per repository, each with testing evidence and its own cost, from a developer who was interrupted only for decisions.
Run a 30-day agent pilotEngineering leadersLeadership wants evidence from one team before rolling coding agents out further.AI spend management, Agent reliability, Cost dashboard, ROI trackingAn expand-or-stop decision based on the pilot team's own records rather than vendor benchmarks.

Workflow · Trace a spend spike

How do you trace a spike in AI agent spend to its cause?

Mekar takes a team lead from a spend total to the agent run behind it: the cost dashboard shows when and where the money went, the ticket timeline and conversation replay show what the agent was doing, and the requirements history shows why. The failed attempts stay on the ticket's cost, so the fix is judged on the full price of the outcome.

Used by
Team leads and engineering leads
Starts when
The weekly spend review shows agent spend jumped, mostly on one repository.

MKR-1057 · Ticket timeline

  1. 09:12Run 1 started on api
  2. 09:58Step limit reached; continuing (1 of 2)$9.40
  3. 10:41Step limit reached; continuing (2 of 2)$8.75
  4. 11:19Stopped before finishing · draft api#541 marked Incomplete$7.90
  5. 13:05Follow-up added: keep the v1 endpoint
  6. 13:44Run 2 · api#544 opened, checks passed, merged$5.65
Ticket cost
$31.70
Spent before the fix
$26.05
Illustrative ticket timeline with sample figures, not customer data.
  1. Step 1

    Find when and where

    Open the last 7 days, then the last 24 hours for spend per hour. Spend by repository shows which codebase the increase came from, and spend by run outcome shows how much of it went to failed or stopped-early runs.

    Cost dashboard
  2. Step 2

    Open the expensive change

    Sort the pull request list by cost and open the most expensive one that failed its checks or never merged. Every pull request links to its ticket.

    ROI tracking
  3. Step 3

    See what the agent did

    The ticket timeline shows each claim, run, failure and retry. Step limit reached; continuing (2 of 2) followed by Stopped before finishing marks a run that used both continuations and still failed, and the replay shows the tool calls it repeated.

    Agent reliability
  4. Step 4

    Fix the cause and retry

    If the requirements history shows a decision nobody made, add it as a follow-up, which starts a new run carrying the full requirements history. If the run failed for another reason, Retry resumes the failed session instead of exploring the codebase again.

    Agent reliability

Result: The cause of the spike, a corrected ticket, and a cost per merged pull request that still includes the failed attempts.

Workflow · Ship a multi-repository change

How do you ship a multi-repository change without watching the agents?

Mekar lets a developer hand a cross-repository ticket to agents and come back to pull requests that are ready for review: open decisions are settled at intake, run health flags the moments that need a person, and each repository's pull request arrives with its own testing evidence and cost.

Used by
Developers and platform teams
Starts when
One change has to land in an API and in the web app that calls it.
  1. Step 1

    Settle decisions before code

    Create one ticket that targets both repositories. Mekar questions it at intake, each question with options and a recommended choice, and the answers become part of the ticket's requirements.

    Ticket intake
  2. Step 2

    Let run health do the watching

    Each repository gets its own tracked run. A worker restart shows as Worker unresponsive and another worker resumes the run, and a long test suite raises Possible agent stall only after 15 minutes without new model usage, as a warning rather than a timeout. If the agent reaches a decision the ticket left open, the ticket moves to Awaiting human with up to five structured questions.

    Agent reliability
  3. Step 3

    Review evidence and cost together

    Each pull request lists the tests, type-checks, lint and builds the agent ran with their results, the files changed and tests added, and its agent cost.

    ROI tracking
  4. Step 4

    Compare cost per repository

    Spend by repository on the cost dashboard shows what the API and the web app each cost, because a ticket that targets several repositories is metered per repository. The restarted run's usage is counted once.

    Cost dashboard

Result: One pull request per repository, each with testing evidence and its own cost, from a developer who was interrupted only for decisions.

Workflow · Run a 30-day agent pilot

How do you run a 30-day AI agent pilot and decide whether to expand it?

Mekar gives an engineering leader a pilot that produces its own evidence: a workspace for the pilot team, a budget on every ticket, run health that shows where agents needed a person, and a 30-day readout of what the spend delivered, with every figure linked to the tickets behind it.

Used by
Engineering leaders
Starts when
Leadership wants evidence from one team before rolling coding agents out further.
  1. Step 1

    Scope the pilot

    Give the pilot team its own workspace, choose a Mekar-managed LLM key or bring your own, and set a budget on each ticket when it is commissioned. Each ticket names the repositories its agent may change.

    AI spend management
  2. Step 2

    Track where agents needed a person

    The board shows tickets moving from Ready to In progress, Awaiting human, Done or Failed. Awaiting human questions and Stopped before finishing runs show where agents needed help, and the ticket says why.

    Agent reliability
  3. Step 3

    Read the 30-day spend

    At day 30, switch to the pilot workspace and open the last 30 days: total spend, spend by repository and model, and the share that went to failed or stopped-early runs.

    Cost dashboard
  4. Step 4

    Decide on delivered work

    Put cost per merged pull request, tests added per dollar and verification pass rate beside the spend. Every pull request links to its ticket, requirements and conversation, and to the reviewer's approval when the ticket has one, so anyone reviewing the decision can check a figure.

    ROI tracking

Result: An expand-or-stop decision based on the pilot team's own records rather than vendor benchmarks.

What do these workflows depend on?

Mekar workflows start when someone opens the cost dashboard or a ticket, where Mekar shows run health and spend against the ticket's budget. Plan reviews around the data's freshness and its fixed time ranges.

Spend freshness
Hourly batch; pull request costs are live
Time ranges
Last 24 hours, 7, 30 or 90 days, or 12 months; no custom ranges or exports
Checks
The commands the agent ran in its own session, not your CI pipeline
Business value
Mekar records cost and engineering output, not revenue or time saved

Security and governance

Your keys. Your repositories. Your approval.

Mekar hosts and operates the platform and is designed for security review. Credentials are encrypted and never exposed to the browser, agents work only within the scope you approve, and a human reviewer makes the final decision on every outcome.

Control summary for security and compliance review

ConcernMekar control
Credential custodyAES-256-GCM at rest; never returned to the client
Hosting and operationsMekar hosts and operates the agent runtime and database
Segregation of dutiesNamed reviewer approval required before work is Done
Change traceabilityRequirements, actions, outputs and approvals retained
Least privilege for agentsExplicit per-ticket repository scope
Cost accountabilityPer-run, per-token ledger with approver identity
  • Encryption at rest

    LLM API keys and repository access tokens are encrypted with AES-256-GCM before they are stored, using a random IV and an authenticated tag.

  • Secrets never reach the browser

    After a credential is saved, the console only shows its provider, model and last four characters. Keys are checked with the provider before they are accepted.

  • Redacted audit history

    API keys, authorization headers, access tokens, system prompts and raw model logs are removed before conversation history is shown.

  • Human approval before work is done

    Assign a named reviewer to each ticket. Only that person can approve work as Done, and only after every target has completed successfully.

  • Explicit repository scope

    Agents only work in the repositories that were selected for a ticket. They never infer, guess or widen their target.

  • Isolated agent runtime

    Agents run in a dedicated container. Its control port is bound to loopback and protected by session-key authentication.

  • Hosted and operated by Mekar

    Mekar runs and maintains the platform, including the agent runtime and its database, so your team has no agent servers to deploy, patch or monitor.

  • Hardened authentication

    Passwords are hashed with BCrypt. Sessions expire after 12 hours, are stored only as SHA-256 hashes and are revoked on the server at sign-out.

  • No shared fallback credentials

    A run without its own authorized credential fails safely. It never quietly falls back to a shared key.

FAQ

Frequently asked questions about Mekar

Direct answers about Mekar's AI agent infrastructure: what the platform does, how it manages AI agent costs, how it monitors agent runs, what it integrates with and what you need to get started.

Platform capabilities

  • What is AI agent infrastructure?

    AI agent infrastructure is the software that runs AI agents as part of everyday engineering work: it queues and executes agent runs, supplies model credentials, meters what each run costs, watches run health and keeps the results for human review. Mekar is an AI agent infrastructure platform for AI coding agents. It runs them against your tickets and repositories on infrastructure Mekar hosts and operates, and records the cost and outcome of every run.

    Read the Mekar overview
  • What happens when Mekar runs an AI agent on a ticket?

    Mekar first questions the ticket to settle decisions nobody wrote down, then starts one agent run for each repository the ticket names. The agent edits, tests and commits in its own checkout, and the Mekar worker pushes the commits and opens a pull request with the agent's testing evidence and cost. When the ticket has a named reviewer, only that person can approve the work as Done.

    See what is built into every ticket
  • Which AI agent does Mekar run?

    Mekar runs coding agents through the open-source OpenHands Agent Server, which gives each agent terminal, file editor and browser tools. The agent runs in a dedicated container whose control port is bound to loopback and protected by session-key authentication, and it never receives your repository token.

    Review the agent runtime controls
  • Does Mekar replace CI or code review?

    No. Mekar records the tests, type-checks, lint and builds the agent ran in its own session, which is evidence for reviewers but not a substitute for your CI pipeline. Mekar opens pull requests and never merges them on its own, so your existing review and merge process stays in place.

    See how verification evidence is recorded

AI cost management

  • How does Mekar calculate what an AI agent run costs?

    Mekar records the provider cost, input and output tokens and model of every agent run against the ticket that requested it. Cumulative provider usage is reconciled into a transactional ledger, so retries, follow-ups and worker restarts are never counted twice, and failed runs are metered like successful ones.

    Explore AI spend management
  • Can Mekar break AI spend down by team, repository and model?

    Yes. Mekar's cost dashboard breaks agent spend down by repository, model, requesting user, run outcome and, at organization scope, workspace. A ticket that targets several repositories is metered per repository. The dashboard updates from an hourly batch over fixed ranges from the last 24 hours to the last 12 months, and it has no exports or custom date ranges.

    See the cost dashboard

Agent monitoring

  • How does Mekar tell whether an AI agent is stuck?

    Mekar raises Possible agent stall when 15 minutes pass with no new reported LLM usage while the agent's worker keeps checking in. It is a warning, not a timeout: long tests can be silent, so the run keeps executing and a person decides whether to step in. Separately, step limits and stuck detection end agents that repeat themselves without progress.

    See every run-health signal
  • What happens when an AI agent run fails in Mekar?

    Mekar continues a run that reaches its step limit in the same session, up to two times by default. If the run still fails, Mekar publishes its committed work as a draft pull request marked Incomplete, and Retry resumes the failed session on the same model while keeping the ticket's cost and event history.

    See how Mekar recovers runs
  • Do developers have to watch Mekar's agents while they run?

    No. Mekar shows each executing run's health on the board and on its ticket, and a worker restart is recovered by another worker without a person. Developers step in when Mekar flags a run or when the agent moves a ticket to Awaiting human with up to five structured questions; answering them resumes the same conversation.

    Follow a multi-repository workflow

Integrations

  • Which LLM providers does Mekar support?

    Mekar works with Anthropic, OpenAI, OpenRouter and Google Gemini keys, and with any OpenAI-compatible base URL, such as a model gateway you run. Teams can also start on an LLM key that Mekar manages. Mekar checks each key with its provider before accepting it and stores it encrypted with AES-256-GCM.

    See the LLM key options
  • Which Git hosts does Mekar integrate with?

    Mekar connects to GitHub, GitLab and Bitbucket with a personal access token and discovers the account's private and public repositories. Agents work only in the repositories a ticket selects, and Mekar's worker, not the agent, uses the token to push commits and open the pull or merge request.

    Review repository scope controls
  • Does Mekar have an API?

    Yes. Mekar exposes a REST API for every action in its console, so tickets, follow-ups, retries and reporting can be automated from your own tools.

Getting started

  • Where does Mekar run?

    Mekar is a hosted platform: Mekar runs and maintains the agent runtime, the OpenHands Agent Server and the PostgreSQL database that records every run, so your team has no agent infrastructure to deploy or operate. You connect a Git host and an LLM key, and agents push their work to your repositories as pull or merge requests.

    Review the security controls
  • What do you need before Mekar can run its first ticket?

    Mekar needs three things before an agent can work on your code: an LLM key, either the Mekar-managed key or your own, a GitHub, GitLab or Bitbucket connection whose token can push branches and open pull requests, and a workspace that maps the repositories agents may change. You then describe the outcome you want as a ticket.

    Plan a pilot in a demo

Request a demo

See how Mekar delivers verified, accounted-for work in your organization

Share a few details and the Mekar team will reply to schedule a session focused on your priorities.

  • A live ticket intake, showing how Mekar's questions expose hidden decisions before an agent starts work
  • The automated testing evidence a reviewer sees, alongside per-ticket spend and ROI reporting
  • A review of encryption, access controls and audit trails with your security team
  • A walkthrough of whether a managed LLM key or your own key suits your organization

Fields marked with an asterisk are required.

0/1000

We use these details only to respond to your demo request.