Lesson 8.2Lesson 8.2 · Judgment, Ethics & Control
The Architect of Record
An agent can do a great deal of the work, but professional responsibility rests on a licensed human who is accountable for safety, compliance and the duty of care - and that accountability can never be delegated to a tool, because a tool cannot hold it and "the AI did it" is not a defence anyone will accept
An agent can draw it, calculate it, specify it and document it - but it can never be responsible for it. That is still, and always, you.
There is a word for the person who answers for a building: not the software that helped draft it, not the consultant who advised on a corner of it, but the licensed professional who directs the work and puts their name and seal to it - the architect of record. It is a legal and ethical role, not a job title, and it carries a weight that predates AI by centuries: the duty of care to the client and the public, accountability for the safety and code-compliance of what is built, and liability when something goes wrong. Interior designers carry an equivalent professional responsibility for the work they sign, specify and deliver. Agents change how much of the work gets done by a machine; they change nothing about where that responsibility sits.
This is the load-bearing idea of the whole course, and this lesson makes it precise. An agent is a tool - an unusually capable, autonomous one, but a tool - and a tool cannot hold professional responsibility. It cannot owe a duty of care, cannot be sued, cannot be struck off a register, cannot stand before a client or an authority and answer for a decision. So when an agent does the work, the responsibility does not travel with the work; it stays with the human who directed it. "The AI did it" is not a defence, because there is no one and nothing on the other end of that sentence to accept the consequence. The professional does. This lesson draws the practical line - what may be delegated to an agent and verified, and what may never be delegated at all - and explains why holding that line is exactly what lets you use agents boldly rather than dangerously.
Delegate the work, keep the responsibility. The seal is yours; so is the liability. No tool can stand in that chain.
What "architect of record" actually means
The architect of record is the licensed professional who takes responsibility for a project - who directs the design work, exercises professional judgement over it, and signs and seals the drawings and documents that go to the authority and to construction. It is a role defined by accountability, not by who moved the mouse. Behind it sits a body of professional obligation that the profession has built over its whole history: a duty of care to the client and, crucially, to the public who will occupy and pass by the building; responsibility that the design is safe, complies with the applicable codes and regulations, and is fit for its purpose; and legal liability if it is not. In India this responsibility is formalised through registration with the Council of Architecture and the obligations that come with the licence; equivalent professional duties bind interior designers for the scope they take on. The specifics vary by jurisdiction; the principle is universal.
The essential feature of this responsibility, for our purposes, is that it attaches to a person, not to a task. It is not "whoever drew the stair is responsible for the stair"; it is "the licensed professional of record is responsible for the building, including the stair, however it was drawn." This is deliberate and it is protective: the public needs a competent, accountable human answerable for the safety of what is built, someone who can be held to a standard, questioned, and made to answer. That is what a licence is - society's mechanism for placing responsibility on a qualified human who has accepted the duty of care.
Agents do not fit anywhere in this structure, and cannot be made to. A tool cannot hold a licence, cannot owe a duty of care, cannot be found negligent, cannot compensate a harmed party, cannot be disciplined by a professional body. There is no mechanism - legal, ethical or practical - by which responsibility could rest on an agent, because responsibility requires a party who can bear consequences, and a piece of software is not such a party. This is not a temporary gap that better AI will close; it is structural. So no matter how much of the work an agent does, the accountability remains exactly where it was before agents existed: on the licensed human who is the architect of record. The work is delegable. The responsibility is not.
Responsibility attaches to a licensed person, not to a task. An agent has no place in that chain to stand.
What may be delegated - and what never can
Holding responsibility does not mean doing everything yourself; it means directing and answering for the work. So the practical question is where the line falls between what you can hand to an agent (and verify) and what you must keep entirely in your own hands. The line is clear once you see it: delegate the work around design; never delegate the responsibility or the core judgement.
On the delegate-and-verify side sits the large, growing category this whole course is about: gathering and synthesising precedents, codes and product data; turning a brief into a structured programme; generating and comparing options; drafting schedules, specifications and documents; running first-pass analysis and modelling; handling routine production and administration; flagging possible code issues for you to check. All of this an agent can do, under your direction, provided you verify what matters (Module 8.1) - because here the agent is doing the work and you are exercising judgement over the result. Delegation with verification is not abdication; it is exactly how a principal has always worked through a team, now with an agent as part of that team.
On the never-delegate side sit the things that constitute your professional role itself. The professional sign-off - putting your name and seal to the work - is by definition yours; it is the act of accepting responsibility, and it cannot be performed by a tool. The duty of care for safety and the client's and public's interest cannot be handed over, because a tool cannot owe it. The core creative and ethical judgement - deciding what is good, what is right for this place and these people, what to accept and what to reject - is the substance of design and the reason a client engages you, not an agent. The client relationship and the trust in it is human. And final accountability for compliance and fitness stays with you no matter who or what produced the document. The test is simple: if a task is really the exercise of professional responsibility or judgement, it is not delegable - an agent may inform it, never make it. Everything else, delegate boldly and verify.
Delegation is not abdication - directing and verifying
The danger is not delegation; it is the quiet slide from delegation into abdication - from "the agent did the work and I checked it" to "the agent did the work and I trusted it." The two look similar in the moment and are worlds apart in consequence, and the difference is entirely in whether the human is still genuinely exercising judgement or has become a rubber stamp on output they did not really engage with.
Staying the architect of record in practice means remaining the director and the verifier, not a passive recipient. You set the goal and the constraints; you understand the work well enough to judge whether it was done right; you verify anything that matters against an authoritative source; you make the actual decisions about what is good and what is acceptable; and you put your name to the result knowing what is in it. When you work this way, an agent is a powerful extension of your practice and you carry the responsibility knowingly, which is exactly as it should be. The productivity is real and the accountability is intact.
Abdication is the failure to do this while pretending you have. It looks like accepting a fluent agent output without understanding it; signing a document you did not really review because the agent produced it and it looked professional; letting the agent's confidence substitute for your own judgement; or delegating something that was never yours to delegate - a safety judgement, a compliance decision, the sign-off itself - and telling yourself the tool handled it. The catastrophic version is the designer who, when the error surfaces, reaches for "the AI did it" - and discovers that this sentence has no standing at all. There is no party it points to who can accept the consequence; the responsibility was always yours, and the authority, the client, the court and your professional body will hold you to it exactly as if you had drawn every line by hand. Delegation with verification keeps you the accountable professional; abdication makes you the accountable professional who did not do their job. The line between them is judgement, exercised - the one thing an agent cannot supply and you can never hand over. Guard it, and you can delegate almost everything else with confidence.
Delegate the work, keep the judgement. A rubber stamp is still your seal - and still your liability.
Why holding the line lets you use agents boldly
It would be easy to hear all this as a brake - a list of things you are not allowed to do with agents - but it is the opposite. Clarity about where responsibility sits is precisely what makes bold, extensive use of agents safe rather than reckless. The designer who is entirely clear that they remain the architect of record can hand agents an enormous share of the work, because they know they will direct it, verify what matters, and answer for the result knowingly. The line is not a limit on how much you can use agents; it is the condition under which using them a lot is professional rather than dangerous.
Contrast the two failure modes this frees you from. One is fearful under-use - the designer who avoids agents because they are anxious about responsibility, and so foregoes real productivity while their responsibility was never actually at risk from the tool. The other is reckless over-trust - the designer who delegates freely but forgets they are accountable, accepts output without verifying, and ships confident errors under their seal. Holding the line escapes both: you use agents boldly because you are clear you remain responsible, and you stay safe because that clarity keeps you verifying and judging rather than rubber-stamping. Responsibility understood is not a constraint on capability; it is what lets capability be used.
There is also a professional and commercial truth in this, especially for small Indian studios weighing whether to adopt agents at all. Your value to a client has never been that you personally performed every task; it has been that you take responsibility for the outcome, exercise judgement a client cannot, and stand behind the work. Agents do not erode that value - they concentrate your time on it, taking over the grind so you can spend more of yourself on the judgement, the design and the relationship that are the actual profession. The studios that thrive will be those that delegate the work aggressively and hold the responsibility firmly - that treat agents as a way to do more of what only they can do, while never letting go of the accountability that is the whole basis of being trusted with a building in the first place. Use agents to their fullest; remain, always, the human who answers for the result.
The professional sign-off & seal
Putting your name to the work
This IS the act of accepting responsibility - it cannot be performed by a tool. In India, tied to Council of Architecture registration. Never signed on trust of an agent alone.
The duty of care
Obligation to client and public safety
A tool cannot owe a duty of care and cannot be made to. It stays with the licensed human, undiminished by however much of the work an agent did. Module 8.2, 8.4.
Core creative & compliance judgement
What is good, right, safe and code-compliant
The agent may inform these; only the professional makes them. Delegating the judgement itself is abdication, not delegation. Verify agent output before it informs a decision (8.1).
Final accountability
Answering for the built result
"The AI did it" points to no party who can bear the consequence. The client, authority, court and professional body hold the human of record. Plan for this permanence.
Workshop — draw your delegation line
Being the architect of record is abstract until you apply it to your own tasks. In this workshop you will sort a real project's work into what you can delegate-and-verify and what must stay with you, and write the responsibility rule your studio will actually follow.
A real project's task list and a notebook. No AI needed - this is about drawing the line before you rely on the tool.
Goal: an explicit, defensible line between delegable work and non-delegable responsibility Inputs: a real project's task list + this lesson + a notebook Time: ~40 minutes
- 1List 10-12 concrete tasks and decisions from a real project, deliberately including some judgement/sign-off items (choose the concept, approve a life-safety detail, seal the drawings, decide a specification, reassure a worried client).
- 2Sort each into DELEGATE-AND-VERIFY (an agent can do it, you check it) or NEVER-DELEGATE (professional responsibility or core judgement) - and for any you hesitate on, write why.
- 3For each DELEGATE-AND-VERIFY task, name the verification step that keeps you the accountable professional (what you check, against what source).
- 4For each NEVER-DELEGATE item, write one sentence on what makes it non-delegable - a duty of care, a licensed sign-off, a core judgement, or the client relationship.
- 5Write a one-paragraph 'responsibility rule' for yourself or your studio: what you will always delegate, what you will never delegate, and how you will guard against the slide from delegation into abdication.
You’ll walk away with
A one-page delegation line for a real project - tasks sorted, verification steps named, and a written responsibility rule. Keep it and apply it as agents take on more of your work.
Three altitudes on the same idea
Read the band that fits you — or all three.
You are the architect of record: the licensed human who directs the work, exercises judgement over it, and seals it - and that role, with its duty of care and its liability, cannot be transferred to any tool. Delegate the work around design to agents freely and verify what matters; but keep in your own hands the professional sign-off, the safety and compliance judgements, the core design decisions and the client relationship. Guard against the slide from delegation into abdication - a document you signed without truly reviewing is still your liability, produced by an agent or not. In India your registration with the Council of Architecture formalises this; wherever you practise, "the AI did it" points to no one who can answer. You do.
You carry professional responsibility for the scope you take on - the specifications you issue, the safety and suitability of what you deliver, the commitments you make to a client - and an agent cannot carry any of it for you. Hand agents the research, the option-generation, the scheduling, the documentation, and verify what becomes a commitment; but keep the judgement about what is right for the space and the client, the sign-off on what you specify, and the trust the client places in you. The value a client pays for is that you take responsibility and exercise judgement they cannot - agents concentrate your time on exactly that, they do not replace it. Delegate the work; own the outcome.
Learn early that being a professional means being accountable - that the licence you are working toward is society's way of placing responsibility on a qualified human who accepts a duty of care. Agents will let you produce a great deal of work fast, and the temptation will be to treat their fluent output as finished and to let the tool "be responsible." It cannot be. Build the habit now of understanding the work well enough to stand behind it, of verifying rather than trusting, and of keeping the judgement in your own hands. The professionals who thrive will delegate the work to agents boldly and hold the responsibility firmly - and "the AI did it" will never be a sentence they need, because they never let go of the accountability that makes them worth trusting.
“As agents get more autonomous and reliable, the vendor or the AI itself will start to carry the liability - so eventually the human architect will not really be the one on the hook for what an agent produces.”
Do it yourself
Reason it through against your own practice.
- 1In one sentence, what does it mean to be the architect of record, and why can a tool not be one?
- 2Give two tasks you would delegate to an agent and two decisions you never would - and say what separates them.
- 3What is the difference between delegation and abdication, and where exactly does it lie?
- 4Why is "the AI did it" not a defence when an agent's error reaches a built project?
- 5How does being clear about responsibility let you use agents MORE boldly, not less?
The one line to carry out
Peer-reviewed journals & authoritative standards
- 01Professional responsibility — Wikipedia — Professional responsibility, 2026.
- 02Duty of care — Wikipedia — Duty of care, 2026.
- 03Architect — Wikipedia — Architect, 2026.
- 04Human-in-the-loop — Wikipedia — Human-in-the-loop, 2026.
Responsibility for the work is one duty; protecting what flows into and out of the agent is another. Next: the confidentiality, data and authorship questions that agentic practice raises.
The author
Amogh N P
Architect, interior designer, and creative polymath. Studio Matrx began in his notebooks — his vision of design made honest, useful, and open to everyone. Its Academy is written and taught in his memory, and free, forever.
More about Amogh →