Four modules, and what they connect

The security every module inherits

The foundation owns no business logic, it owns the security the agents must pass through. It is included under every module, and that is why the portfolio can grow without being rebuilt for every customer.

• Never broader than the person behindThe agent never sees more than the person asking is allowed to see in each system.
• Confirmation before writingNo account, invoice or access is changed without a human saying yes first.
• Identity all the way to the edgeEvery action is performed as you, through your own identity platform.
• One log, one traceEvery question and every action is logged with the same trace through the whole process.

Start with one module, build towards the whole ground.

We set up a pilot on the module that is most urgent, on one system and a contained scope, so you see the value before you connect the rest.

A won sale becomes customer, project and billing basis on its own

When a deal is marked as won and the contract is signed, the customer, the project and the billing basis are created in the finance system by themselves, exactly once, without anyone re-entering them. The CRM owns the sale, the finance system owns the money, and the foundation carries the message between them.

Between sales and finance sits a manual handoff

A deal is marked as won in the CRM. Then the double work begins: someone recreates the customer in the accounting system, sets up the project by hand and builds the billing basis from a quote in another system. The contract gets signed, but the word of it does not always reach the people who should invoice.

The result is familiar: customers that exist in two variants with different spellings, projects that do not match between sales and accounting, and invoices sitting and waiting because no one knew the basis was ready. The pipeline number and what has actually been invoiced live in separate worlds.

The CRM owns the sale, the finance system owns the money

Neither system loses its role. The CRM owns the pipeline and the deal, the finance system owns the customer, the project and the invoice. What the foundation does is carry the message between them: when a deal is marked as won and the contract is signed, the customer is created or updated, the project is set up and the billing basis is made ready. It happens exactly once. If the network fails and the message is sent again, the customer is still not created twice.

From won deal to billing basis

Ask across sales and finance, in Teams or Slack

When sales and finance are linked in the same chain, you can ask across them where you already work, in Teams or Slack, through Microsoft Copilot, Claude or ChatGPT. The question that used to require someone to open both the CRM and the accounting system and compare them is now answered in the thread.

Other cross-system questions the agent answers:

• What is the expected revenue from won deals this month, compared with what has been invoiced?
• Was the customer created in the accounting system for this deal, and with the correct organization number?
• Which signed contracts are still missing a project in the finance system?
• Does the deal value in the CRM match the billing basis that is ready?

Teams  ·  Slack  ·  Microsoft Copilot  ·  Claude  ·  ChatGPT

Connected to the CRM and finance system you already use

Where both systems have an open API, we connect them directly. The CRM side can be one of the common sales systems, and the finance side one of the common accounting and business systems. The signed contract becomes the event that triggers the transfer, through the e-signature solution you already use. The rules for what gets created, and when, are set together with you, so the connection mirrors your actual sales and invoicing process.

Sales and invoice connected

• No double entryThe customer is created once, from CRM to accounting, with no manual re-entry.
• One customer truthThe same customer and the same project across sales and finance, without two variants.
• Invoice on timeThe billing basis is ready the moment the contract is signed, not days later.
• Pipeline versus actualExpected revenue and invoiced amounts lined up against each other, in real time.
• Confirmed, not blindCustomer, project and invoice are only created once a human has said yes.
• The last link in the chainSales stand on the same foundation as identity, recruitment and finance.

From pipeline to delivery, on one ground

With this link in place, a deal goes all the way without manual jumps: the sale is won in the CRM, the contract is signed, the customer and project land in the finance system, and the project can be staffed through the same agents that are already standing. Sales was the open end. Now pipeline, contract, finance and delivery are connected on the same ground, and you can ask about the whole flow from one place.

Watch the link close.

We connect the CRM, the signing and the finance system on one contained flow, so you see a won deal become customer, project and billing basis before you expand to the rest.

The accounting system knows the answer. Now you can just ask.

An agent that connects the finance system to the same foundation as the rest of the operation, so you can ask about invoicing, hours against budget and due dates where you already work, and get the answer without logging in.

The numbers exist, but they are heavy to reach

The finance system keeps track of every invoice, every hour and every project. Yet the answer to a simple question is often a detour: someone has to log in, find the right report, filter it and paste the result into an email, and in the meantime a manager has made a decision on gut feeling because the number was not available in time.

The controller becomes the bottleneck for questions others should be able to ask themselves. A project manager wondering whether hours are blowing the budget, a department head who wants to know what has been invoiced, a CEO who wants to see overdue invoices, they all go through one person and one tool.

The accounting is up to date. The distance to it is the problem.

The finance system owns the numbers, the foundation is the way in to them

We connect your finance system to an agent standing on our foundation. The system still owns every single number: bookkeeping, hours and invoices stay where they always have, and the agent creates no version of truth of its own. It retrieves, it assembles, and if it is to write anything back, it waits for a human.

The agent reaches the system through MCP, the same standardized set of hands that the rest of the platform uses. Reading is broad and fast, writing is scoped and confirmed, and everything goes through the same ground with access limits and a log.

Asking

Acting

Ask where you already sit

The point of connecting the finance system is not the integration itself, but that a question about finance can be asked and answered where you already work, in Teams or Slack, through Microsoft Copilot, Claude or ChatGPT. You do not open the accounting system, you ask about it, and the answer comes in the same thread.

Other questions the agent answers without you opening a tool:

• Do we have overdue invoices older than 30 days, and who are they for?
• Which projects are above budgeted hours this month?
• What have we invoiced so far this quarter, compared with the last one?
• How many hours have been logged on this project, but not invoiced?
• Are there vouchers missing approval before the month-end close?

Teams  ·  Slack  ·  Microsoft Copilot  ·  Claude  ·  ChatGPT

Never broader than the person behind the question

Financial figures are not one room everyone should enter. A controller sees the whole picture, a project manager sees their project, a department head sees their department. The agent inherits the same limit. It combines what it can do itself with what you are allowed to see, and never answers more than you would have seen by logging in yourself. If two people ask the same question, they each get their own answer, from the same agent.

Connected to the finance system you already use

Where the system has an open API, we connect the agent directly. That applies to most modern Norwegian accounting and business systems. For systems without a suitable interface, we build a scoped layer on the same ground, so the chain is the same regardless of where the numbers live. The rules for what the agent may read and write are set together with you.

Finance accessible, control intact

• Answers right awayInvoicing, hours and due dates answered in Teams or Slack, without the detour through a report.
• Controller freed upRoutine questions answer themselves, so the finance function spends its time on what needs a brain.
• Nothing written blindlyInvoicing and booking only happen once a human has confirmed the draft.
• The right access for each personEveryone sees their own, never more. It is enforced by the foundation, not by an instruction to the language model.
• Full traceabilityEvery question and every action is logged, so audits are easy to document.
• The next stone in the foundationFinance stands on the same foundation as identity and access, so you keep building.

The foundation first, finance as the next link

Once identity and access are in place, the foundation stands: the HR system decides who exists, the foundation enforces what they are allowed to do, and the agents answer in Teams or Slack. Finance is the natural next link, because it meets the same foundation and the same security, and because the numbers are connected to the projects, the hours and the people already wired in. You add one system, not a new platform.

Try asking the accounting system.

We connect one finance system and a contained set of questions, so you get a feel for what it is like to get the answer in Teams or Slack before you expand.

The right access from day one, a clean close on the last

Two agents that turn changes in the HR system into real access: account, tools and licenses set up when someone starts, and closed the same day someone leaves. Whoever it concerns, and whatever the HR tool.

Manual on- and offboarding costs time, money and security

When someone is hired, IT has to create an account, assign the right license and set up access. It often takes several days, and the new hire sits ready on their first day without being able to get into the systems.

When someone leaves, offboarding is the task that is most easily forgotten. The result is orphaned accounts that still have access to customer, personal and financial data, a security risk, a finding in any audit, and a license still being paid for someone who has left.

HR always knows first. Yet it is IT that carries out the changes manually, usually via email and tickets, and between the two links delays and errors arise.

The HR system decides, the agent executes, the foundation enforces

We connect your HR system to Entra ID through an agent standing on our foundation. The agent reaches the systems through MCP, a standardized connection that makes changes and retrieves answers the same way every time. The rules for who gets which access lie in the foundation, beneath the language model. They are enforced by the system, not left to an instruction the model can choose to follow. That is what lets the lifecycle run by itself without anyone losing sleep.

Onboarding

Offboarding

One that opens, one that closes

Not just automatic, also on demand

The same connection that lets the agent create an account or close an access is also one you can ask questions through. The point of building this is not the integration itself. The point is that you can ask about something and get an answer, without logging into Entra, without opening the HR system and without sending a ticket to IT.

You do not need to learn a new tool for this. You ask where you already work, in Teams or Slack, through Microsoft Copilot, Claude or ChatGPT, and get the answer in the same thread.

Teams  ·  Slack  ·  Microsoft Copilot  ·  Claude  ·  ChatGPT

Connected to the HR tool you already use

Some HR systems can create users in Entra ID on their own, and are connected directly. For the others we build a scoped layer that does that job, on the same foundation. The rules are built together with you, so they reflect your actual obligations, not a generic template.

An owned outcome, not a rented point solution

• Access from day oneNew hires are productive from their first day, without waiting for IT.
• No orphaned accountsAccess is revoked the moment someone leaves. The most common security weakness is gone.
• The right license costYou pay for active users, not for people who have left.
• Answers where you workAsk in Teams or Slack and get the status of access and licenses without opening a single tool.
• Governance you own yourselvesThe rules for who gets access to what live in your foundation, not with a vendor.
• The first stone in the foundationThe same foundation carries the next service, so you build on instead of starting over.

The licenses managed, the agent included

SkyeTec manages the Microsoft licenses on your behalf and scales the number in step with your staffing. The price runs per license, with both the license and the agent included. The only things you choose are the HR tool and the number of licenses.

See the lifecycle in practice.

We set up a pilot on one HR system and a scoped number of licenses, so you see on- and offboarding run by itself before you scale.

From application to signed contract and a prepared workplace

A recruitment solution where the agents read, assess and prepare, the human decides, and everything connects to the HR system, the identity and the signing you already have. And where you can ask about status where you work, without opening the tool.

The CV pile takes time, gut feeling decides, and the cleanup is forgotten

Recruitment drowns in manual work. Applications pile up while someone reads them one by one, the assessment becomes subjective and hard to verify, and the status of a candidate is scattered across inboxes and heads.

After signing, a new race begins: account, work email and HR profile must be in place before day one, often manually, often too late. And when the process is over, the deletion deadlines for personal data become the task that never gets done, until it turns up as a finding in the audit.

The agents prepare, the human decides, the foundation watches

The recruitment solution stands on the same foundation as the rest of the platform. The agents reach the systems through MCP, the same standardized connection that both retrieves status and performs actions. Reading is open to agents that are approved. Changing anything requires a logged-in human, and every step is logged. One rule is never moved: decisions about people are made by people, as regulation requires.

End to end

Five steps, without manual handoffs

1. 01 Assessed in seconds

   The agent reads the CV and application, extracts structured facts and calculates a score against the role's requirement profile, before the candidate has closed the confirmation page. The recruiter starts from insight.

   Measured at ours: 9 seconds from submission to score
2. 02 Verifiable, not guesswork

   The agent extracts the facts, while the scores themselves are calculated by fixed rules you can read. The same CV gives the same score every time, and it is always possible to see which version of the rules was used. Personal data is removed before the text is sent to the language model.

3. 03 The process guides

   The candidate card always shows one clear next step: interview guides built on the candidate's actual strengths and gaps, structured feedback, comparison in the same chart and a print-ready assessment report for the decision meeting.

4. 04 Sign first, create afterwards

   The contract goes to digital signing before anything else happens. Only when the candidate has actually signed are the user account, work email and HR profile created, automatically through the same chain. No half-finished identities for those who decline.

5. 05 The system cleans up after itself

   The deletion deadline is set the moment the application is received and adjusted at every status change, with a warning before deletion and anonymization on hire. Cleanup is a property of the system, not an annual volunteer effort.

Run the recruitment in conversation, through MCP

Recruitment does not only happen inside the tool. Because the solution has an MCP interface, it can be run from where the work otherwise takes place: in Teams or Slack, through Microsoft Copilot, Claude or ChatGPT. A manager asks about status and gets the answer in the thread, without logging into the recruitment tool.

Teams  ·  Slack  ·  Microsoft Copilot  ·  Claude  ·  ChatGPT

Connected to the landscape you already have

The solution adapts to the systems you already have: your HR system, your identity platform, your signing provider and your career pages. Each connection can be swapped out or turned off without affecting the rest. If a system is missing, that part of the flow falls back to the usual manual routine instead of stopping completely.

One event, one system or several

An application from the career page enters the recruitment flow, and from there the parts play together. If the message only needs to go to one system, it goes straight there. If it needs to go to several, it goes through a common backbone, so there is one place that knows what actually happened. The signature is the moment that triggers the account being created.

Recruitment in operation, not an AI experiment

• Assessed in secondsEvery application is scored against the requirement profile before the recruiter gets to open it.
• Assessment that can be verifiedFixed rules give the same score on the same CV, and it is always possible to see which version of the rules was used.
• No orphaned identitiesAccount and profile are only created after a signed contract, never before.
• GDPR built inDeletion deadlines are enforced by the system, and personal data is stripped before every AI call.
• Answers where you workStatus on the process is fetched in Teams or Slack, without opening the tool.
• The human decidesThe agents prepare and inform, decisions about people are made by people.

In production on our own hires

The solution is not a demo. It runs in production on SkyeTec's own hires, built with the same method and architecture we deliver to customers. We know it works, because we recruit with it ourselves, and because it went from first line of code to production in weeks.

See the process in practice.

We connect the career page, the HR system and the signing on one scoped flow, so you see an application go all the way to a prepared workplace before you scale.