# talaia > Human-in-charge accountability standard for work done with AI: a certificate a person signs, and a method (Brief → Build → Watch → Sign) that makes the signature honest. The signature is one line added to the work, address and name: `talaia.dev/certificate — John Doe`. In software, `git commit -s` with the address in the message. The standard follows in full, as published at https://talaia.dev. **English** · [Español](es/README.md) · [Català](ca/README.md) # Manifesto ## Introduction Generative AI is faster at producing answers than humans are at thinking them through. When generating becomes cheaper than thinking, the path of least resistance takes over: the AI proposes, the human accepts, and speed starts replacing thought. That shift creates risks that are easy to miss: - **Judgment drifts away from the person.** The faster the machine can produce, the easier it becomes to stop questioning, exploring and deciding deliberately. - **Accountability dissolves.** Work goes out that nobody fully understands: code, a report, a post. When it fails, "the AI wrote it" explains nothing: a machine cannot own an outcome. - **Understanding erodes.** Tests pass, drafts go unread, and people sign off on what they cannot explain. - **Design erodes.** AI is good at producing locally plausible pieces, but local plausibility is not global coherence. Without someone holding the intent, structure starts being accumulated rather than designed. - **Plausibility replaces value.** Generated work often looks complete and correct, but looking right is not the same as being useful, true or worth making. - **Existing controls weaken.** Reviews, roles and definitions of done still matter, but they need to evolve when machines perform a significant part of the work. None of this is an argument against AI. **It is an argument against surrendering judgment to speed.** AI should make production cheaper, not thinking optional. The question is not whether AI produces the work. It is who remains in charge of it. ## What we hold Talaia stands on a simple conviction: the human person comes first, and no tool can take the place of human judgment or responsibility. Two kinds of tower say it better than we can.[^4] Babel: one tower, one direction, one language for everyone, built upward in the belief that scale itself was progress, and when it fell, no one could understand anyone, or explain what had been built. And the *talaies*[^5]: the low watchtowers that line the Mediterranean coast. No one raised them from above; each one was built by a village to watch its own stretch of sea. Inside each there is a person who answers for what they see, and the alarm passes from tower to tower by fire. The choice in front of us is not "yes" or "no" to the technology; it is which of the two towers we are building: Babel (one tower, all scale, no one accountable) or the *talaies* (many small towers, each one watched). The watchtower does not hold back the sea. Someone in it keeps watch, and answers for what passes. Keeping that order, we have come to value:[^1] **Human judgment** over machine autonomy **A person who answers** over a system with no owner **Understanding what goes out** over accepting what works **Deliberate design** over generated accumulation **Knowing when not to use it** over using it because it is there **Work that serves people** over work that merely looks complete A tool serves best when it strengthens the person who works and fails the moment it invites that person to stop being present. Talaia adheres in full to [The Pro-Human AI Declaration](https://humanstatement.org/), which also inspired it. ## What AI is At Talaia we know that AI is software, and only software. It is not alive: it has no intelligence or perception comparable to a person's, no spirit, no desires of its own. It does not understand what it produces. It imitates language, analysis, even empathy and care, and the imitation can be useful; but its learning is statistical adjustment over data, not the growth of someone shaped by choices, mistakes and time. And it is not neutral: its answers carry the choices and assumptions of the few people who designed and trained it, so what sounds like a fact may be their opinion. That makes Talaia more than a proposal for how to work with AI. It is a defense of human work with AI: against the ways of working that dilute responsibility, and against replacing human grace, talent and personality. AI should augment our intelligence, through the tool, not replace it. We have much more to bring to this world. We call the principle that follows from this **human-in-charge**. # Human-in-charge ## The principle Human-in-charge means that every use of AI has a person in charge of it: someone who decided it should exist, designed how it works, understands it, and answers for it by name. It is not a human placed in the path of a system to approve each thing the system produces. It is a person who stands behind the system itself. Take a process that uses AI to classify a thousand emails a day. Nobody needs to read, check and understand a thousand classifications; that would undo the reason for building it. What must be true is that a person can say what the process is for and what value it brings, how it is built and where the AI sits in it, what can go wrong and what happens when it does, and that the outcome is theirs. The machine may act a thousand times with no one watching. It never acts on its own authority: it acts on the authority of the person who put it there, inside the limits that person drew. Being in charge is held at three levels, and none of them is the output of an automation: - **Responsibility.** A named person answers for what the system does, including what it does when no one is looking. - **Design.** A person decided what is handed to the machine and what is not, knowing the risks and the value. The structure was designed, not accumulated. - **Understanding.** A person understands the code and the structure that carry the AI, and can explain how they work and why without the help of an AI. We hold this as a belief, not a proposal. The harm AI can do is avoided only when **every** use of AI has a human in charge of it, without exception, as an obligation and not a recommendation. ## How to apply it Responsibility is not taken from a person: it is given up a little at a time, one unexamined delegation after another, until none is left. Each step is comfortable. The system quietly shapes how people work and judge, it is accepted until it is no longer seen, and what was built comes to look inevitable.[^6] What is lost on the way is cognitive sovereignty: a person's own judgment. The defence is friction: - **Stop and ask** who decided that this should be handed to the machine, and by what measure its answers count as correct. - **Keep deciding, deliberating and doubting**, even though thinking is tiring and the machine is not. - **Follow no oracle.** No guru, model or algorithm can carry the responsibility of choosing. - **Do not delegate what cannot be optimised** or reduced to a calculation. Talaia makes this practicable by bringing the manifesto and the Certificate of Understanding into every piece of work where AI is used. The manifesto is the frame: why the person stands above the tool. The certificate is the practice, and it is signed over what a person makes (the code, the structure, the design of the automation), not over each thing the automation later produces. Where there is no name, nobody is in charge. # The Certificate of Understanding ## The Certificate The Certificate of Understanding is a tool for applying the manifesto and the human-in-charge principle day to day, for people who work with AI. Its statements aim to sum up the actionable part of the manifesto. The text, in the shape of the DCO:[^2] ```txt Certificate of Understanding Version 1 — talaia.dev/certificate By signing off on this work, I certify that: (a) The work was created, in whole or in part, with the assistance of an AI, at my direction and to a brief that was mine; and (b) I have read the work in full; I understand what it says and why, and can explain it without the help of an AI; I have checked what it claims, and its opinions and assumptions are mine; and I take responsibility for the work and make it my own. I sign this in keeping with the talaia manifesto: talaia.dev ``` Two clauses, and the signature means both at once: the machine was here, and a person answers for what it made.[^3] ## Against Co-Authorship The certificate records assistance, never co-authorship. An author is not the one who produced the words but the one who stands behind them. To author is to mean something and to be held to it. That takes a self with something at stake, and a machine has none. Some tools say otherwise. Claude Code, by default, ends the commits it writes with a git trailer that names the machine as an author: ```text Co-Authored-By: Claude ``` We are against that use and against that definition. The trailer is not just a label: GitHub and other forges read it and list the machine next to the person, as an author of the change. Calling it a co-author turns help into authorship, and splits the responsibility between a person and something that cannot answer for anything. ## How to use it The text lives at [talaia.dev/certificate](https://talaia.dev/certificate) and is never signed there. You sign by adding one line to the work: ```text talaia.dev/certificate — John Doe ``` Two parts, in that order: - **The address** is the certificate. It points at a fixed text, so the line means the same thing wherever it appears, and clause (a) is already in it: an AI was here. - **The name** is the certification. A person is here, and both clauses are true of them. Adding the line *is* the act; the gesture is deliberate, and it is yours. Under a post, the line as it is. At the foot of a report, the address once and one name per hand, because the work passed from hand to hand (the analyst to the head of finance, the head of finance to the board), and each hand adds its own name under the last: ```text talaia.dev/certificate John Doe, Head of Finance, 2026-09-14 Jane Roe, CEO, 2026-09-16 ``` In a commit, the address goes in the message and `-s` writes the name as the `Signed-off-by:` trailer; the reviewer's sign-off on the pull request is the next hand: ```sh git commit -s -m "feat: export orders as CSV (#42)" -m "talaia.dev/certificate" ``` ```text feat: export orders as CSV (#42) talaia.dev/certificate Signed-off-by: John Doe ``` The lines accumulate, and every one of them is a person who read the work in full and answers for it. That is the chain of towers: the fire passes, and at every tower someone is watching. # Talaia The manifesto and the certificate are the same for everyone. What changes is who adopts them, and there are two ways in: a person or a team, on their own; or a company, as a whole. ## For individuals and teams Talaia is open and free to use, and nobody's permission is needed. You already have the certificate. What remains is the way of working that makes signing it honest: the framework, which says how to brief the AI, how to read what comes back, and when to sign: a post, a report, a commit. For software there is also a small tool that installs the rules your AI agent works under and checks that every commit carries a signature. All of it is under [Individuals and Teams](#framework). ## For companies A company can make the manifesto its own: its values held across the whole organization, so that people stay in charge of the work AI helps them make. The certificate is how that shows, and it goes in three directions: inside the company, every piece of work carries the name of a person who read it and answers for it; to customers, it is delivered as a seal on what the company hands over; and from distributors, it is required for what the company receives. See the [Companies](#companies) tab for the services we offer to help companies apply Talaia, and for other related services. # Framework ## Introduction The manifesto says what we stand for; the certificate says what a person promises; the framework is how the promise becomes possible. Talaia does not replace the way you already work; it sits underneath it. Stories can live in Jira, GitHub Issues or a text file; a report can still be a Word document; a post is still a post. What talaia adds is a boundary between what may be delegated and what must remain human: - **The instrument may** draft, build, test, iterate and report. - **The instrument may not** design the system, decide what counts as done, accept its own work, sign it, or put it into the world. Those acts are yours. **Working output is not accepted work.** ## The framework Like Scrum or Kanban, talaia is a method before it is a tool. Unlike them, it works per piece of work, not per sprint, so it runs under whatever process you already have. It has five steps. The first is done once per system; the other four are a loop, run once per piece of work: ``` DESIGN ───▶ ( BRIEF ───▶ BUILD ────▶ WATCH ───▶ SIGN ) person person instrument person person, in the work itself ``` | Step | Who | What happens | Done when | |------|-----|--------------|-----------| | **Design** | You | You write what the system is: architecture, conventions, constraints. | It is written and you approve it. | | **Brief** | You, with the instrument | You say what must be true; the instrument asks about what is loose. | No question is left open. | | **Build** | The instrument | It makes what was briefed, and shows the evidence. | The Brief is true and the evidence is shown. | | **Watch** | You | You read what came back and keep only what you approve. | You can explain everything you kept. | | **Sign** | You | You add the line: the address and your name. | The work carries your name. | Work with an AI is a conversation: something is asked, something comes back, and the next turn corrects the last. The loop keeps that shape: Brief, Build and Watch turn until you are satisfied, and the Sign closes it. You direct at the start and answer at the end. None of it is new ceremony. The Design is what you already know about your system, written down; the Brief is the asking itself; Build is the instrument working inside the rules; the Watch is you reading what came back; the Sign is the line you add. Together the steps draw a single line: **execution may be delegated; judgment may not.** ### Design: the human says what the system is Nothing is asked yet. The Design is what is true of the system, written down by you before the first Brief: 1. **The architecture.** What the system is, what it is made of, and the principles it keeps. 2. **The conventions.** What "done right" looks like here: how the work is made, checked and written. 3. **The constraints.** The hard limits: what may not be done even if it works, and the choices that bind what comes after. Every kind of work has all three: a codebase; a publication (its line, its house style, what it never prints); a series of reports. Three rules keep it yours: - **The instrument does not design the system.** It may help you word the Design and format it; it never changes it on its own. - **Every Brief is read against the Design.** If an ask contradicts it, or the work shows it wrong or incomplete, the instrument says so and stops. - **Only you reopen it.** The instrument goes on when you have decided: by rewriting the Design yourself, or by dictating the change. **Done when:** the Design is written and you approve it. Until then, no Brief starts. Signing it as you sign any other work (the line, your name) is good practice; nothing checks it. ### Brief: the human says what "done" means Nothing is produced yet. The Brief is not a meeting and not a form: it is your ask, in your own words, and the conversation that follows it. 1. **You say what you want**: what must be true when the work is finished. 2. **The instrument reads the ask against the Design and the project** (the code, the sources it is working in) and returns what is loose: a contradiction, an open question, a decision the ask leaves to be taken. 3. **You answer.** The instrument takes none of those decisions itself: nothing of design, architecture or higher order, and no substantial change: a library swapped, a structure reshaped, a capability added or removed. **Done when:** no question is left open. While one remains, the Brief turns. When none is left, the instrument starts Build on its own, without asking permission: the ask, what "done" means and every decision are already yours. ### Build: the instrument works Nothing is decided here. The instrument works to the Brief, under seven rules: 1. **The smallest thing.** The least that makes the Brief true. 2. **Nothing more, nothing less than briefed.** No features, abstractions or "improvements" nobody asked for; nothing that was asked for silently dropped. 3. **What a person wrote stays as they wrote it.** Hand-made content is not touched, above all your edit to something the instrument produced. That edit is a decision, and the next turn works around it, not over it. Only an explicit ask reopens it. 4. **Proof first, and it never bends.** Where the work can be tested, the failing test is written before the work and shown failing; where it cannot, the check is named before the work starts. Tests and checks are never deleted, skipped or weakened. 5. **Every claim comes with its evidence.** "Tests pass" counts only as the real output of tests that ran, shown. "According to the data" counts only with the source beside it. 6. **The work stays watchable.** Small enough to be read in full in one sitting, coherent enough to be explained without help. When it grows past that, it is split. 7. **Iterate, never insist.** If the same failure survives two attempts, the instrument stops and returns the decision to you. **Done when:** what was briefed is true and its evidence is shown, or two attempts have failed and the decision is back with you. ### Watch: the human keeps guard The Watch happens where the work already is: the diff in your editor, the document on your screen, the draft in the chat. 1. **Read every part you are about to accept.** If you cannot explain a hunk, a paragraph, a figure, do not accept it: ask, or take it over by hand. 2. **Check the evidence, not the claim.** The tests ran in front of you, real output included; the sources open; the numbers trace. Anything still marked *unverified* is verified by you or removed. 3. **Keep only what you approve.** In code, hunk by hunk, staging the ones that pass; in a document, paragraph by paragraph, leaving the rest out. 4. **Send back the rest.** All of it or a part: it goes round the loop again until it is what you asked for. Tools may scale the reading, never the judgment. Semantic diffs, review assistants, summarizers: use whatever helps you read; the decision to accept stays yours. **Done when:** you have read everything you kept, you can explain it, and nothing in it is still unverified. ### Sign: the human answers for it You add the line (the address and your name) in the work itself; in software, the commit. **The instrument does not sign, does not publish, does not write history.** In software: no `add`, no `commit`, no `push`, no `merge`. No state-changing git command, ever. Reading history is allowed. **Done when:** the work carries your name. The instrument iterates; you decide when the loop ends, and the signature is that decision. ## Assurance Anyone can add the line without having read a word of the Build. No machine will catch it, and the framework does not pretend one will. What the line changes is what the work *is*: whoever receives it reads it as yours (not the machine's, not a draft, not a proposal) and judges it as your work is judged. So assurance comes from the signer. The line does not check the work; it makes the work yours, and what carries your name you do properly, because your name is what people will ask for when it fails. **The certificate does not add a control. It removes an excuse.** The receiver's part is to trust the signature, and to ask; responsibility has always meant asking the one who signed. Why this and not that; what would break it. Whoever read the work and made it their own can answer without the tool. Whoever signed without reading finds out what the signature meant. # In practice ## Content and documents An article, a post, a report. The Design is your rules for every piece: tone, style, what you never publish. Write it once and give it to the assistant first. Brief and Build are the conversation. The Watch is reading the draft and keeping only what you accept. The Sign is the line, added by hand. Under a post, as it is: ```text talaia.dev/certificate — John Doe ``` At the foot of a report, the address once and one name per hand: ```text talaia.dev/certificate John Doe, Head of Finance, 2026-09-14 Jane Roe, CEO, 2026-09-16 ``` ## Software Software is the medium where the framework maps onto gestures you already make, and where the rules are strictest: **the instrument does not write git.** No `add`, no `commit`, no `push`, no `merge`. Nothing enters history without a human decision. The Design is three files in `.talaia/`, at the root of the repository (`architecture.md`, `conventions.md`, `constraints.md`), written by you, read by the agent on every turn, and committed and signed like any other change. The agent writes in them only at your dictation. The rules for the agent go in the instructions file it reads on every turn. Every coding agent takes one, under one name or another (`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`); the rules go there once, and the agent works inside them from then on. > [talaia.dev/agentsmd](https://talaia.dev/agentsmd) This is `AGENTS.md`: the framework written for the agent. It lives at one address, so every copy of it says the same thing. Save it at the root of the repository; each tool reads it from its own place (Claude Code, Codex, Gemini, Cursor, Copilot). How, for each one: [talaia.dev/how-to-agentsmd](https://talaia.dev/how-to-agentsmd). Brief and Build are the conversation with the agent, under those rules. Watch and Sign are git: - **Watch is the diff and the stage.** You read the change in your editor, hunk by hunk, and stage what you accept: staging is the first act of acceptance. - **Sign is the commit.** You write the message in your own words (the agent never drafts it; if you cannot write the message, you cannot commit) with the address in it, and `-s` writes your name as the trailer: ```sh git commit -s -m "feat: export orders as CSV (#42)" -m "talaia.dev/certificate" ``` ```text feat: export orders as CSV (#42) talaia.dev/certificate Signed-off-by: John Doe ``` - **The pull request is the next hand.** The reviewer reads the change and puts their own sign-off behind yours; the pull request template asks the certificate again, in front of the team, where review already happens. The agent ends every finished piece of work with the certificate and the command to sign. Same trailer, same gesture, same enforcement as the DCO: if your project already uses it, one sign-off certifies both: talaia adds understanding on top of origin, never replacing it. The forge can hold the gate. A check runs on every pull request and fails when a commit in it carries no `Signed-off-by:`; make it a required check and no signature means no merge. > [talaia.dev/pr-check](https://talaia.dev/pr-check) One file. Where to put it on GitHub, GitLab, Bitbucket or Gitea, and how to make it required, is at [talaia.dev/how-to-pr-check](https://talaia.dev/how-to-pr-check). # Using talaia This part is for software only: it applies when the work lives in a git repository. ## Quick start Install once, then two commands inside your own repository: ```sh go install talaia.dev/cmd/talaia@latest # once; Go 1.23+ is the only requirement cd ~/your-project talaia init # the instructions file, the design files, the pull request template, the check talaia hooks claude # optional: deny git writes in the agent's own settings (claude, gemini, git) talaia audit --strict # any time: are the commits signed? (read from git) ``` Write the design in `.talaia/`, commit the scaffold, open your AI tool, and work as usual. The CLI executes no AI and makes no network calls; it creates files, edits only the settings list that `hooks` owns, and reads git history. `talaia help` lists the commands. ## talaia init Run it at the root of your repository. It creates the harness (eight files) and touches nothing else: ``` AGENTS.md The framework rules for AI agents CLAUDE.md, GEMINI.md Redirects to AGENTS.md (Claude Code, Gemini CLI) .github/ ├── PULL_REQUEST_TEMPLATE.md What, why, how it was tested + the certificate └── workflows/talaia.yml The audit check on every pull request .talaia/ The design: yours to write ├── architecture.md Overview, structure, principles ├── conventions.md Coding and development conventions └── constraints.md Hard limits and binding decisions ``` | | | |---|---| | **The rules** (`AGENTS.md`) | The file at [talaia.dev/agentsmd](https://talaia.dev/agentsmd), as it is; yours to adapt. `CLAUDE.md` and `GEMINI.md` are one-line imports of it: put no rules in them. Where every other tool reads it: [talaia.dev/how-to-agentsmd](https://talaia.dev/how-to-agentsmd). | | **The design** (`.talaia/`) | The truths of the system: architecture, conventions, constraints. Seeded with `TODO` placeholders for you to write, before the first Brief. The agent reads them on every turn and never changes them on its own: it stops and asks, and writes there only at your dictation. | | **The pull request template** | Applied by the forge to every pull request: what changed, why, how it was tested, and the two certificate clauses as checkboxes, ticked in front of the team. | | **The check** (`.github/workflows/talaia.yml`) | The file at [talaia.dev/pr-check](https://talaia.dev/pr-check), as it is: `talaia audit --strict` over the pull request's commits. Make it required and no signature means no merge: [talaia.dev/how-to-pr-check](https://talaia.dev/how-to-pr-check). | **`init` is idempotent and never destructive.** Existing files are left exactly as they are; only missing files are created. ## talaia hooks `AGENTS.md` tells the agent never to run a state-changing git command. `talaia hooks` makes the agent refuse, even when it forgets the rule. ```sh talaia hooks claude # .claude/settings.json talaia hooks gemini # .gemini/settings.json ``` Adds to the agent's versioned settings one deny rule per git write: `add`, `am`, `apply`, `branch`, `checkout`, `cherry-pick`, `clean`, `commit`, `merge`, `mv`, `pull`, `push`, `rebase`, `reset`, `restore`, `revert`, `rm`, `stash`, `switch`, `tag`. Read-only git stays open. It reaches everyone who clones; the rest of the file is kept, and running it twice changes nothing. ```sh talaia hooks git # .git/hooks/, this clone only ``` Installs `reference-transaction` and `pre-push`, which refuse commits, branches, tags and pushes when git is called from inside an agent, recognised by `CLAUDECODE`, `GEMINI_CLI`, `CODEX_SANDBOX`, or `TALAIA_AGENT=1` for any other. It works with any agent, but does not cover `add`, `reset --hard` or `clean`. Run it again after every fresh clone; an existing hook is never overwritten. None of this is a security boundary: an agent can call git another way. What holds against a deliberate bypass is that the commit carries the person's name. ## talaia audit Assurance is a by-product of git, not a report. `talaia audit` reads the history (one `git log`, read-only, merge commits skipped) and says whether the signatures are there: how many commits carry `Signed-off-by:` and a story id, and which do not. With `--strict` it exits with status 1 on any unsigned commit. A missing story id or an oversize commit is only reported; that is what the pull request check runs. Narrow it with whatever you would pass to git log: `talaia audit main..feature`, `talaia audit --since=2026-08-01`. [^1]: Inspired by the [Manifesto for Agile Software Development](https://agilemanifesto.org/). [^2]: Inspired by the [Developer Certificate of Origin](https://developercertificate.org/). [^3]: Designed to support the human review and editorial responsibility of Article 50(4) of the [EU AI Act](https://eur-lex.europa.eu/eli/reg/2024/1689/oj). [^4]: Inspired by the encyclical [*Magnifica Humanitas*](https://www.vatican.va/content/leo-xiv/en/encyclicals/documents/20260515-magnifica-humanitas.html) of Leo XIV (2026), where the choice is not "yes" or "no" to technology but building Babel or rebuilding the wall [^5]: See [Watchtower](https://en.wikipedia.org/wiki/Watchtower) on Wikipedia. [^6]: We are also inspired by [*Humanismo Tecnológico Disidente*](https://humanismotecnologicodisidente.com/) (Jesús Granero, 2025): not rejecting technology, but not worshipping it. # For companies ## Every use of AI in the company, with a person in charge of it. Your teams already work with AI: in code, in reports, in processes that run on their own. What a customer, an auditor or your own board will ask is not whether AI was used. It is who decided it should be, who understands what it does, and who answers when it fails. talaia gives the company that answer: values held across the organization, a way of working that keeps judgment with people, and a signature that shows it in every piece of work. ### What the company adopts Not a tool, and not a new process. A position on AI, held by the whole organization before any tool is chosen. - **The manifesto** The company's values on AI: human judgment over machine autonomy, a person who answers over a system with no owner, understanding what goes out over accepting what works, and knowing when not to use it. - **Human-in-charge** Every use of AI has a named person in charge: someone who decided it, designed it, understands it and answers for it. That includes the automations nobody watches: the person answers for the system, not for each thing it produces. - **The framework** The line between what may be delegated and what must stay human. The design written once per system, then Brief, Build, Watch, Sign for each piece of work, under the process you already have. ### One practice, three directions The Certificate of Understanding is how all of it shows: the same two clauses a single person signs. Adopted by a company, it becomes a good practice that travels with the work. - **Inside the company** Every piece of work done with AI (code, a report, a post, an automation) carries the name of a person who understands it and answers for it. The names accumulate as the work goes up: the author, the reviewer, the board. - **To your customers** Deliver the certificate as a seal on what you hand over: an AI helped make this, and a named person stands behind it. - **From your distributors** Require it of those whose work you receive, the way you already require any other standard of quality. ## Services ### We help you adopt it, or we build it for you. #### Adopting talaia - **Training** Teams that get more from AI, and know where it stops. For every role, not only engineers. - **Audit** Know where you stand before anyone asks. Every use of AI mapped: who owns it, what is signed, what is not. - **Consulting** talaia, fitted to how you already work. Your processes, your tools. Nothing thrown away. #### Engineering - **AI projects** Agents and automations that take real work off your plate. And an honest no when AI is not the answer. - **Software engineering** Products built fast, owned by your team. Designed by people, built inside written rules. - **Process optimization** Find where the time goes. Automate what should be, with a person in charge of every step. - **Forward deployed engineers** Our engineers, inside your team. Delivering with your people until it runs without us. ## Products ### Proof you can show. Software that builds itself. **Official certification** Proof, not promises. Anyone can adopt the open standard on their own word. Official certification puts our name behind yours: a seal your customers can check, in every tender and every contract. ## aguait ### Software that builds itself. People who answer for it. aguait is automatic software development on the principles of talaia. We set it up in your company. - **Your design** You write the design once. aguait builds from it. - **On its own** From design to finished change, no code typed. - **Signed** Nothing ships without a name behind it. - **With you** We install it, tune it and train who runs it. ### Bring talaia to your company Tell us where you are. We will show you where to start. Contact: the form on https://talaia.dev/companies