01
Agentic workflows
Agents that take a task end to end: read the inbox, pull the record, make the decision, write the result back. With a human checkpoint wherever you want one.
AI engineering studio
AI systems that do the work.
We design, ship and run production AI for teams that are done experimenting. Custom agents, automations and internal tools: scoped in a week, live in weeks, owned by you.
30 minutes, no pitch deck. You leave with a written scope and a number.
agent · invoice-intake
live- Read 14 new emailsinbox
- Extracted 11 invoices9 PDF · 2 scan
- Matched to purchase orders11/11
- Flagged 1 mismatch for reviewhuman
- Posted to ledgerwriting…
4m 12s0 errors
- Fixed scope, fixed price
- You own the code and the keys
- Two-week build cycles
- We reply within hours
What we build
Six things we ship, over and over.
Every engagement is custom, but the shapes repeat. If your problem looks like one of these, we have already solved the hard parts.
- 02
Document & data extraction
Invoices, contracts, forms, scans. Structured output your systems can actually consume, with a confidence score and a source citation on every field.
- 03
Internal copilots
A private assistant that knows your handbook, your tickets and your history. It answers with citations, and says it does not know instead of inventing.
- 04
Process automation
The manual chain between your tools, replaced. Triggers, retries and back-off built in, plus an alert the moment something needs a person.
- 05
The software around the model
Dashboards, review queues, approval flows, admin panels. Hand-coded, fast, and designed for the person who has to use it forty times a day.
- 06
Evaluation & monitoring
Test suites, regression checks and live dashboards, so you know the system still works next quarter, not just on the day we demoed it.
Agentic workflows, Document extraction, Internal copilots, Process automation, Custom software, Evaluation & monitoring, Data pipelines, Human-in-the-loop review
Our position
Most AI projects die between the demo and production. Ours ship, because we design for the boring parts first.
The model is the easy part. What decides whether a system survives contact with your business is everything around it: where the data actually lives, what happens on the malformed input, who gets told when it fails, and whether the person downstream trusts the output enough to stop double-checking it.
- 01Boring first
- Data access, edge cases, error handling and permissions get designed before a single prompt.
- 02Measured, not claimed
- We agree on the number that defines success before we start, and we report it after.
- 03Handover by default
- Everything is written so your engineers could take it over tomorrow. Some do.
Why OREL
Three things that are unusual about working with us.
01
Engineers, not resellers
There is no wrapper on someone else’s product here. We write the code, choose the models and can walk your team through every line of it. When something breaks at 2am, the person who built it picks up.
- Hand-written code, no low-code black boxes
- Model choice driven by evals, not by a partnership
- Direct access to the people building it
02
Scoped before it is sold
You get a fixed scope and a fixed price in writing after the mapping session, before you commit to anything. We would rather turn a project down than discover halfway through that it never made sense.
- Written scope and price up front
- Success metric agreed before we start
- We say no when the numbers do not work
03
You own everything
Code, prompts, evaluations, infrastructure and API keys live in your accounts from day one. If you decide to run it yourself or hand it to another team, nothing has to be untangled first.
- Your cloud, your keys, your repository
- Documentation written for handover
- No lock-in and no hostage data
How it works
Four steps from a problem to a system that runs.
No discovery phase that bills for three months. You know the scope, the price and the target after the first week.
- 01Week 1 · free
Map
One working session on your real process, with the people who do it. We find where the hours go, which steps a model can be trusted with, and which ones must stay human.
- 02Week 1 · fixed price
Scope
A written plan: what gets built, what it costs, what it should save, and how we will measure it. If the return is not there, we tell you and we do not take the project.
- 03Weeks 2-8
Build
Two-week cycles, each ending in something that runs. You see working software instead of status reports, and you steer before it is expensive to change.
- 04Ongoing · optional
Run
We deploy it, watch it and tune it against real traffic. Then you take the keys, or we keep operating it on a monthly basis. Your call, either way.
Model & tool agnostic
Built on the stack you already run.
We pick the model and the infrastructure that fit the problem, then wire it into the tools your team opens every morning. Nothing here is a vendor we resell.
Models
- OpenAI
- Anthropic
- Open weights
Cloud
- AWS
- Azure
- Google Cloud
- Self-hosted
Data
- Postgres
- Supabase
- Snowflake
- S3
Work
- Slack
- Notion
- HubSpot
- Google Workspace
Responsible by design
Built to be trusted with the real thing.
Systems that touch invoices, contracts or customers need more than a good demo. These are defaults on every project, not upsells.
Your data stays yours
Isolated infrastructure per client, and provider settings configured so your data is not used for training.
Human in the loop
Any consequential action can require approval. You decide what the system is allowed to do alone.
Full audit trail
Every run records its inputs, outputs, model version and cost. You can always answer why it did that.
Fails loudly
Guardrails, fallbacks and alerting. A system that stops and asks beats a system that quietly guesses.
EU-based team
Built and operated from Bulgaria, inside the EU, with GDPR obligations designed in rather than bolted on.
No model lock-in
Providers sit behind an interface. Swapping to a cheaper or better model is a config change, not a rewrite.
Engagements
Three ways to start.
Most teams start with a Sprint and move up once they have seen the system work on their own data.
Sprint
2 weeksOne process, mapped and automated end to end.
For teams that want proof on their own data before committing to a bigger build.
- Mapping session and written scope
- One workflow built and deployed
- Evaluation set on your real cases
- Handover documentation
Most projects start here System
4-8 weeksA production agent or internal tool, built properly.
The full build: interface, integrations, guardrails, monitoring and rollout to your team.
- Everything in Sprint
- Custom interface and integrations
- Human review queues and permissions
- Monitoring, evals and alerting
- Team training and rollout
Operate
MonthlyWe keep what is live running and getting better.
For systems in production that need someone watching them and improving them every month.
- Monitoring and incident response
- Model and prompt tuning
- New workflows added as you need them
- Monthly performance report
Exact pricing comes on the call, in writing, before you commit to anything. We take a limited number of projects at a time because we work on one system until it is right.
Questions
The things everyone asks.
Anything not covered here, ask on the call. Or email us and we will answer in writing.
That is what the mapping session is for, and it is free. We look at the actual process with the people who run it and tell you honestly which parts are worth automating and which are not. If the answer is that nothing is, you get that in writing and we part on good terms.
A Sprint puts one workflow into production in two weeks. A full system is typically four to eight weeks depending on how many integrations it touches. You see working software at the end of every two-week cycle, not at the end of the project.
You get a fixed price in writing after the mapping session, before you commit to anything. Pricing depends on how many systems the work has to touch and how much review the output needs, so we quote after we have seen the process rather than guessing on a website.
You do, entirely. Code lives in your repository, infrastructure runs in your cloud accounts, and API keys are yours from day one. We document everything for handover, so your own engineers can take it over whenever you want.
We assume it will. Every system is built with guardrails, confidence thresholds and a human review path for the cases it is not sure about. You decide where those thresholds sit, and the audit trail lets you see exactly what happened on any run.
Often, yes. We can build alongside your team, review their work, or hand over completely once it is live. Code is written to be read by someone else from the start, which makes all three straightforward.
A small engineering team based in Blagoevgrad, Bulgaria. We also build satellite-based wildfire detection systems, which is where most of what we know about running models on real, messy data in production came from.
Stop evaluating AI. Start running it.
One call, thirty minutes, no obligation. You leave knowing whether there is something worth building and roughly what it would cost.
We reply within a few hours on working days.