The governed assembly layer for agentic enterprise applications.
Where you build agentic workflow applications, and where they run.
Describe the workflow. tvamevaYantra researches it, designs it, plans it and builds it — stopping at every decision that belongs to you. Then it runs what it built: holding the state of each process, calling each agent when its turn comes, passing work between them, and waiting however long your approvers take.
The problem
Real work doesn't fit inside one agent.
A business process runs across a dozen steps and half a dozen systems. Several teams touch it. It takes days, and people have to sign things along the way.
Closing the books at month end. Taking a deal from first enquiry to signature. Onboarding a supplier. Each of these needs several agents that understand different systems, working in order, handing off to each other and to people. One clever agent answering one question is a demo. This is the job.
It runs for days, not seconds
Someone's on leave. An approval sits until Tuesday. The process still has to be there when they get back — and it has to survive every restart in between.
Several agents, different systems
One understands the CRM. Another knows the ledger. A third drafts the document. They have to pass work between them and agree on what’s true.
Step nine fails after step eight already wrote
Something is now half done in a live system. What should happen next is a business question, and it needs answering in advance rather than at two in the morning.
Accountability moves around
Different steps need different people to sign off. At the end, someone has to be able to show who agreed to what.
None of this is new. Enterprises have been orchestrating processes like these for decades. What changed is that some of the steps are now done by agents that reason rather than follow a fixed script — and that makes the sequencing, the state and the accountability harder to get right.
Why a better model won't fix it
A frontier model is excellent at the step in front of it.
It will reason about step six better than most people in the building. That was the hard part, and it's solved.
What a model isn't given is the other eleven steps, the authority to act, or anywhere for the work to live while finance takes the weekend.
No memory of steps one to five
It was handed a task, not a process.
Acts on whatever credential it was given
Not on the authority of the person who actually asked.
Gone when the session ends
And the approval it needs is still sitting with finance.
Nobody signed anything
And there's no record showing that nobody did.
Anthropic's own experiments show the same model failing a task in twenty minutes without a harness, and finishing it over six hours with one. The environment changed, not the model. That environment is what this is.
What Yantra does
It runs the whole workflow — by keeping three jobs apart.
Running a business process end to end means doing three genuinely different things. Collapse them into one prompt and you get a demo. Keep them separate and you get something you can certify.
Control — who runs next, and what’s held
Fixed rules decide which agent runs when and what it’s handed. The state of every process lives here: where each run has got to, what’s done, what’s waiting on whom. No model output moves the workflow forward.
Policy — what’s allowed
One rules engine over every agent. Allow, refuse, ask a person, or allow with conditions. Rules you add can only tighten, never loosen. Each agent acts with the permissions of the real person behind the request, not a shared service account.
Execution — the inner loop
An agent doesn’t get one shot at a step. It reasons, acts, looks at the result and goes again, as many passes as the work needs. The controls sit at the edge of that loop, never inside it.
The agents think freely. They just can't act unchecked.
How you build
Describe it, or write it. The controls are the same either way.
Yantra Studio
You describe the application in ordinary language. It researches, designs, plans and builds, stopping at every decision that belongs to you. You have a conversation; that’s the whole interface. You read a real design document before anything gets built, and you see what the work will cost before you approve it.
The SDK
One typed Python library over every platform service, built so the controls come along whether or not you think about them. The CLI drives the hand-authored path — build, test, run, deploy — against standard application structure. Scaffolding isn’t a stub. You get the project file, the app and workflow modules, a health endpoint, a passing smoke test and all eight config files. It runs from the first minute. What it doesn’t have is your domain logic, which is the part worth your time.
Inside Claude Code
The same governed tools, in the editor you already use. Install the plugin and you talk to Claude about the application you’re building; it reaches tvamevaYantra through the same audited path as everything else. No second client, no separate credentials. Slash commands are sugar over the same tools — /yantra-status types faster than asking in prose and resolves to exactly the same call.
Eight stages. Four of them stop and ask you.
The last stage feeds back into the earlier ones, so an application keeps improving after it ships rather than only before.
Nothing gets built from the conversation alone
The agent works out what to do and proposes it. A named person decides. That’s enforced in the code rather than written into a policy — try to generate without approval and it refuses, having spent nothing.
You approve the real thing
Not a summary of it. The architecture document, the design, the plan and the costs are the same files the build is generated from.
The gates run before the build, not after it
Every build passes the same mechanical gates: security lint · guardrail dry-run · quality thresholds · cost projection · dual-view FinOps. A build that fails one comes back and runs again.
If a control is missing, the software doesn't start — and the engineer finds that out here, rather than in production three months later when governance finally meets.
How it governs
Seven obligations. Every action, every agent.
This is what happens for every step, whether that's an agent calling a tool or a workflow step reaching into another system. It isn't a filter the request passes through on the way somewhere else. It's the path, and there isn't another one.
Everything that decides whether an action should happen at all runs before anything is spent or changed. That's why a refusal costs nothing.
Risk tiering
How risky a tool is decides what happens. Low runs on its own. Medium is flagged for someone to look at. High stops and waits for a person, every time. This gets checked before the application ships — if a high-risk tool can be reached without passing a human first, validation fails and it doesn't deploy.
Evaluation and telemetry
Every run is traced, graded, and turned into a change you can review.
Two harnesses sit in the execution plane and they work as a pair. The observability harness records what actually happened — every span, every step, and what each one cost. The evaluation harness grades it. Together they turn a run from something you hope worked into something you can inspect.
The same request can produce a different answer twice, so exact-match assertions can't grade this. Rubrics can.
What the evaluation harness checks
Answer quality and faithfulness
Scored against a rubric by a judge model — on what a good answer requires, not on matching one recorded earlier.
Document artifacts
The right file, in the right format, with the sections it was required to contain.
Tool invocations
The correct tool called with the correct arguments, read from the execution trace rather than inferred from the output.
External services
The right services reached with the right payload, verified per call.
API contracts
URL, method and payload shape checked against the contract the application declared.
Data state
The system landed in the correct state after the run — not merely that the run finished.
What the observability harness emits
Spans for every step
A full trace of what ran, in what order, and how long each part took.
Cost per step
Attributed at the moment it's spent, per event and per tenant — not reconciled from an invoice later.
Evidence on every failure
The trace shows which step went wrong and what it was holding at the time, so the fix is minutes rather than an afternoon of bisecting.
Trace → reviewable change. That's the loop: the run is recorded, graded against what it should have done, and the gap comes back as something a person can approve or reject.
The architecture
Four surfaces. Fifteen services. One audited path.
Describe the workflow, review the App Plan, hold the approval gate, watch build state.
Typed clients and scaffolds in your editor; the same governed tools inside Claude.
Assembles the workflow: describe, plan, approve, generate.
Five harnesses: Workflow Orchestrator (typed graphs, checkpoints) · Storage Adapter (one API, driver-agnostic) · MCP Harness (REST and MCP from one definition) · Evaluation Harness (trace to reviewable change) · Observability Harness (spans, per-step cost).
Declarative and extensible. Default-deny, constitutional rule packs, guardrails, risk tiering. Where the seven obligations are enforced.
Fifteen typed services
One client, one contract, one audited path
Twenty-two enterprise connectors
Tiered; every one through the same audited surface
Proof the foundation carries real work
Three products. Three unrelated jobs. One platform.
PropelEdge
Revenue Orchestration
Takes a sales pursuit from first enquiry through qualification and a point-of-view deck to a full proposal.
InsightLens
Agentic Finance Intelligence
Helps a finance team close the books faster, working on top of the systems the data already lives in.
EngageOS
Composable DXP
Joins up what sales, marketing, support and finance each know about the same customer.
Three products, three different domains, on the same identity, permissions, audit and metering foundation. None of them wrote any of it.
Get started
Bring us a process that takes days.
Month-end close. Quote to cash. Onboarding a supplier. Pick one that runs across several systems, waits on people, and nobody has managed to automate yet. In thirty minutes we'll walk through what it looks like as a governed application — where the agents sit, where your people sign, and what the audit record shows afterwards. No deck.